Series comparison

-[Qemu-devel] [PULL for-2.10 00/15] Block patches
+[Qemu-devel] [PULL v2 00/24] Block patches
-The following changes since commit 248b23735645f7cbb503d9be6f5bf825f2a603ab:
+The following changes since commit 56f9e46b841c7be478ca038d8d4085d776ab4b0d:
-  Update version for v2.10.0-rc4 release (2017-08-24 17:34:26 +0100)
+  Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2017-02-20' into staging (2017-02-20 17:42:47 +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 3e4c705212abfe8c9882a00beb2d1466a8a53cec:
+for you to fetch changes up to a7b91d35bab97a2d3e779d0c64c9b837b52a6cf7:
-  qcow2: allocate cluster_cache/cluster_data on demand (2017-08-30 18:02:10 +0100)
+  coroutine-lock: make CoRwlock thread-safe and fair (2017-02-21 11:39:40 +0000)
 ----------------------------------------------------------------
 Pull request
 v2:
  * Rebased to resolve scsi conflicts
 ----------------------------------------------------------------
-----------------------------------------------------------------
+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
-Alberto Garcia (8):
+ Makefile.objs                       |   4 -
-  throttle: Fix wrong variable name in the header documentation
+ stubs/Makefile.objs                 |   1 +
-  throttle: Update the throttle_fix_bucket() documentation
+ tests/Makefile.include              |  19 +-
-  throttle: Make throttle_is_valid() a bit less verbose
+ util/Makefile.objs                  |   6 +-
-  throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
+ block/nbd-client.h                  |   2 +-
-  throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
+ block/qed.h                         |   3 +
-  throttle: Make burst_length 64bit and add range checks
+ include/block/aio.h                 |  38 ++-
-  throttle: Test the valid range of config values
+ include/block/block_int.h           |  64 +++--
-  misc: Remove unused Error variables
+ include/io/channel.h                |  72 +++++-
+ include/qemu/coroutine.h            |  84 ++++---
-Dan Aloni (1):
+ include/qemu/coroutine_int.h        |  11 +-
-  nvme: Fix get/set number of queues feature, again
+ include/sysemu/block-backend.h      |  14 +-
+ tests/iothread.h                    |  25 ++
-Eduardo Habkost (1):
+ block/backup.c                      |   2 +-
-  oslib-posix: Print errors before aborting on qemu_alloc_stack()
+ block/blkdebug.c                    |   9 +-
+ block/blkreplay.c                   |   2 +-
-Fred Rolland (1):
+ block/block-backend.c               |  13 +-
-  qemu-doc: Add UUID support in initiator name
+ block/curl.c                        |  44 +++-
+ block/gluster.c                     |   9 +-
-Stefan Hajnoczi (4):
+ block/io.c                          |  42 +---
-  scripts: add argparse module for Python 2.6 compatibility
+ block/iscsi.c                       |  15 +-
-  docker.py: Python 2.6 argparse compatibility
+ block/linux-aio.c                   |  10 +-
-  tests: migration/guestperf Python 2.6 argparse compatibility
+ block/mirror.c                      |  12 +-
-  qcow2: allocate cluster_cache/cluster_data on demand
+ block/nbd-client.c                  | 119 +++++----
+ block/nfs.c                         |   9 +-
- include/qemu/throttle.h            |    8 +-
+ block/qcow2-cluster.c               |   4 +-
- block/qcow.c                       |   12 +-
+ block/qed-cluster.c                 |   2 +
- block/qcow2-cluster.c              |   17 +
+ block/qed-table.c                   |  12 +-
- block/qcow2.c                      |   20 +-
+ block/qed.c                         |  58 +++--
- dump.c                             |    4 +-
+ block/sheepdog.c                    |  31 +--
- hw/block/nvme.c                    |    4 +-
+ block/ssh.c                         |  29 +--
- tests/test-throttle.c              |   80 +-
+ block/throttle-groups.c             |   4 +-
- util/oslib-posix.c                 |    2 +
+ block/win32-aio.c                   |   9 +-
- util/throttle.c                    |   86 +-
+ dma-helpers.c                       |   2 +
- COPYING.PYTHON                     |  270 ++++
+ hw/9pfs/9p.c                        |   2 +-
- qemu-doc.texi                      |    5 +-
+ hw/block/virtio-blk.c               |  19 +-
- scripts/argparse.py                | 2406 ++++++++++++++++++++++++++++++++++++
+ hw/scsi/scsi-bus.c                  |   2 +
- tests/docker/docker.py             |    4 +-
+ hw/scsi/scsi-disk.c                 |  15 ++
- tests/migration/guestperf/shell.py |    8 +-
+ hw/scsi/scsi-generic.c              |  20 +-
-files changed, 2831 insertions(+), 95 deletions(-)
+ hw/scsi/virtio-scsi.c               |   7 +
- create mode 100644 COPYING.PYTHON
+ io/channel-command.c                |  13 +
- create mode 100644 scripts/argparse.py
+ 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, 1712 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%)
 --
-.13.5
+.9.3

-New patch
+[Qemu-devel] [PULL v2 01/24] block: move AioContext, QEMUTimer, main-loop to libqemuutil
+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 ++++++++
 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"
 --
 .9.3

-[Qemu-devel] [PULL for-2.10 11/15] scripts: add argparse module for Python 2.6 compatibility
+[Qemu-devel] [PULL v2 02/24] aio: introduce aio_co_schedule and aio_co_wake
-The minimum Python version supported by QEMU is 2.6.  The argparse
+From: Paolo Bonzini <pbonzini@redhat.com>
-standard library module was only added in Python 2.7.  Many scripts
-would like to use argparse because it supports command-line
+aio_co_wake provides the infrastructure to start a coroutine on a "home"
-sub-commands.
+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
-This patch adds argparse.  See the top of argparse.py for details.
+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
-Suggested-by: Daniel P. Berrange <berrange@redhat.com>
+which AioContext a coroutine is running on.
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Acked-by: John Snow <jsnow@redhat.com>
+aio_co_schedule is the part of aio_co_wake that starts a coroutine
-Message-id: 20170825155732.15665-2-stefanha@redhat.com
+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>
 ---
- COPYING.PYTHON      |  270 ++++++
+ tests/Makefile.include       |   8 +-
- scripts/argparse.py | 2406 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ include/block/aio.h          |  32 +++++++
-files changed, 2676 insertions(+)
+ include/qemu/coroutine_int.h |  11 ++-
- create mode 100644 COPYING.PYTHON
+ tests/iothread.h             |  25 +++++
- create mode 100644 scripts/argparse.py
+ tests/iothread.c             |  91 ++++++++++++++++++
+ tests/test-aio-multithread.c | 213 +++++++++++++++++++++++++++++++++++++++++++
-diff --git a/COPYING.PYTHON b/COPYING.PYTHON
+ 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/COPYING.PYTHON
++++ b/tests/iothread.h
 @@ -XXX,XX +XXX,XX @@
-+A. HISTORY OF THE SOFTWARE
++/*
-+==========================
++ * Event loop thread implementation for unit tests
-+
++ *
-+Python was created in the early 1990s by Guido van Rossum at Stichting
++ * Copyright Red Hat Inc., 2013, 2016
-+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
++ *
-+as a successor of a language called ABC.  Guido remains Python's
++ * Authors:
-+principal author, although it includes many contributions from others.
++ *  Stefan Hajnoczi   <stefanha@redhat.com>
-+
++ *  Paolo Bonzini     <pbonzini@redhat.com>
-+In 1995, Guido continued his work on Python at the Corporation for
++ *
-+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+in Reston, Virginia where he released several versions of the
++ * See the COPYING file in the top-level directory.
-+software.
++ */
-+
++#ifndef TEST_IOTHREAD_H
-+In May 2000, Guido and the Python core development team moved to
++#define TEST_IOTHREAD_H
-+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
++
-+year, the PythonLabs team moved to Digital Creations (now Zope
++#include "block/aio.h"
-+Corporation, see http://www.zope.com).  In 2001, the Python Software
++#include "qemu/thread.h"
-+Foundation (PSF, see http://www.python.org/psf/) was formed, a
++
-+non-profit organization created specifically to own Python-related
++typedef struct IOThread IOThread;
-+Intellectual Property.  Zope Corporation is a sponsoring member of
++
-+the PSF.
++IOThread *iothread_new(void);
-+
++void iothread_join(IOThread *iothread);
-+All Python releases are Open Source (see http://www.opensource.org for
++AioContext *iothread_get_aio_context(IOThread *iothread);
-+the Open Source Definition).  Historically, most, but not all, Python
++
-+releases have also been GPL-compatible; the table below summarizes
++#endif
-+the various releases.
+diff --git a/tests/iothread.c b/tests/iothread.c
 +
 +    Release         Derived     Year        Owner       GPL-
 +                    from                                compatible? (1)
 +
 +    0.9.0 thru 1.2              1991-1995   CWI         yes
 +    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
 +    1.6             1.5.2       2000        CNRI        no
 +    2.0             1.6         2000        BeOpen.com  no
 +    1.6.1           1.6         2001        CNRI        yes (2)
 +    2.1             2.0+1.6.1   2001        PSF         no
 +    2.0.1           2.0+1.6.1   2001        PSF         yes
 +    2.1.1           2.1+2.0.1   2001        PSF         yes
 +    2.2             2.1.1       2001        PSF         yes
 +    2.1.2           2.1.1       2002        PSF         yes
 +    2.1.3           2.1.2       2002        PSF         yes
 +    2.2.1           2.2         2002        PSF         yes
 +    2.2.2           2.2.1       2002        PSF         yes
 +    2.2.3           2.2.2       2003        PSF         yes
 +    2.3             2.2.2       2002-2003   PSF         yes
 +    2.3.1           2.3         2002-2003   PSF         yes
 +    2.3.2           2.3.1       2002-2003   PSF         yes
 +    2.3.3           2.3.2       2002-2003   PSF         yes
 +    2.3.4           2.3.3       2004        PSF         yes
 +    2.3.5           2.3.4       2005        PSF         yes
 +    2.4             2.3         2004        PSF         yes
 +    2.4.1           2.4         2005        PSF         yes
 +    2.4.2           2.4.1       2005        PSF         yes
 +    2.4.3           2.4.2       2006        PSF         yes
 +    2.5             2.4         2006        PSF         yes
 +    2.7             2.6         2010        PSF         yes
 +
 +Footnotes:
 +
 +(1) GPL-compatible doesn't mean that we're distributing Python under
 +    the GPL.  All Python licenses, unlike the GPL, let you distribute
 +    a modified version without making your changes open source.  The
 +    GPL-compatible licenses make it possible to combine Python with
 +    other software that is released under the GPL; the others don't.
 +
 +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
 +    because its license has a choice of law clause.  According to
 +    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
 +    is "not incompatible" with the GPL.
 +
 +Thanks to the many outside volunteers who have worked under Guido's
 +direction to make these releases possible.
 +
 +
 +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
 +===============================================================
 +
 +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 +--------------------------------------------
 +
 +1. This LICENSE AGREEMENT is between the Python Software Foundation
 +("PSF"), and the Individual or Organization ("Licensee") accessing and
 +otherwise using this software ("Python") in source or binary form and
 +its associated documentation.
 +
 +2. Subject to the terms and conditions of this License Agreement, PSF
 +hereby grants Licensee a nonexclusive, royalty-free, world-wide
 +license to reproduce, analyze, test, perform and/or display publicly,
 +prepare derivative works, distribute, and otherwise use Python
 +alone or in any derivative version, provided, however, that PSF's
 +License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
 +2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights
 +Reserved" are retained in Python alone or in any derivative version
 +prepared by Licensee.
 +
 +3. In the event Licensee prepares a derivative work that is based on
 +or incorporates Python or any part thereof, and wants to make
 +the derivative work available to others as provided herein, then
 +Licensee hereby agrees to include in any such work a brief summary of
 +the changes made to Python.
 +
 +4. PSF is making Python available to Licensee on an "AS IS"
 +basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 +IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
 +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
 +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
 +INFRINGE ANY THIRD PARTY RIGHTS.
 +
 +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
 +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
 +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
 +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
 +
 +6. This License Agreement will automatically terminate upon a material
 +breach of its terms and conditions.
 +
 +7. Nothing in this License Agreement shall be deemed to create any
 +relationship of agency, partnership, or joint venture between PSF and
 +Licensee.  This License Agreement does not grant permission to use PSF
 +trademarks or trade name in a trademark sense to endorse or promote
 +products or services of Licensee, or any third party.
 +
 +8. By copying, installing or otherwise using Python, Licensee
 +agrees to be bound by the terms and conditions of this License
 +Agreement.
 +
 +
 +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
 +-------------------------------------------
 +
 +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
 +
 +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
 +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
 +Individual or Organization ("Licensee") accessing and otherwise using
 +this software in source or binary form and its associated
 +documentation ("the Software").
 +
 +2. Subject to the terms and conditions of this BeOpen Python License
 +Agreement, BeOpen hereby grants Licensee a non-exclusive,
 +royalty-free, world-wide license to reproduce, analyze, test, perform
 +and/or display publicly, prepare derivative works, distribute, and
 +otherwise use the Software alone or in any derivative version,
 +provided, however, that the BeOpen Python License is retained in the
 +Software, alone or in any derivative version prepared by Licensee.
 +
 +3. BeOpen is making the Software available to Licensee on an "AS IS"
 +basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 +IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
 +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
 +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
 +INFRINGE ANY THIRD PARTY RIGHTS.
 +
 +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
 +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
 +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
 +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
 +
 +5. This License Agreement will automatically terminate upon a material
 +breach of its terms and conditions.
 +
 +6. This License Agreement shall be governed by and interpreted in all
 +respects by the law of the State of California, excluding conflict of
 +law provisions.  Nothing in this License Agreement shall be deemed to
 +create any relationship of agency, partnership, or joint venture
 +between BeOpen and Licensee.  This License Agreement does not grant
 +permission to use BeOpen trademarks or trade names in a trademark
 +sense to endorse or promote products or services of Licensee, or any
 +third party.  As an exception, the "BeOpen Python" logos available at
 +http://www.pythonlabs.com/logos.html may be used according to the
 +permissions granted on that web page.
 +
 +7. By copying, installing or otherwise using the software, Licensee
 +agrees to be bound by the terms and conditions of this License
 +Agreement.
 +
 +
 +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
 +---------------------------------------
 +
 +1. This LICENSE AGREEMENT is between the Corporation for National
 +Research Initiatives, having an office at 1895 Preston White Drive,
 +Reston, VA 20191 ("CNRI"), and the Individual or Organization
 +("Licensee") accessing and otherwise using Python 1.6.1 software in
 +source or binary form and its associated documentation.
 +
 +2. Subject to the terms and conditions of this License Agreement, CNRI
 +hereby grants Licensee a nonexclusive, royalty-free, world-wide
 +license to reproduce, analyze, test, perform and/or display publicly,
 +prepare derivative works, distribute, and otherwise use Python 1.6.1
 +alone or in any derivative version, provided, however, that CNRI's
 +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
 +1995-2001 Corporation for National Research Initiatives; All Rights
 +Reserved" are retained in Python 1.6.1 alone or in any derivative
 +version prepared by Licensee.  Alternately, in lieu of CNRI's License
 +Agreement, Licensee may substitute the following text (omitting the
 +quotes): "Python 1.6.1 is made available subject to the terms and
 +conditions in CNRI's License Agreement.  This Agreement together with
 +Python 1.6.1 may be located on the Internet using the following
 +unique, persistent identifier (known as a handle): 1895.22/1013.  This
 +Agreement may also be obtained from a proxy server on the Internet
 +using the following URL: http://hdl.handle.net/1895.22/1013".
 +
 +3. In the event Licensee prepares a derivative work that is based on
 +or incorporates Python 1.6.1 or any part thereof, and wants to make
 +the derivative work available to others as provided herein, then
 +Licensee hereby agrees to include in any such work a brief summary of
 +the changes made to Python 1.6.1.
 +
 +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
 +basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 +IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
 +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
 +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
 +INFRINGE ANY THIRD PARTY RIGHTS.
 +
 +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
 +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
 +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
 +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
 +
 +6. This License Agreement will automatically terminate upon a material
 +breach of its terms and conditions.
 +
 +7. This License Agreement shall be governed by the federal
 +intellectual property law of the United States, including without
 +limitation the federal copyright law, and, to the extent such
 +U.S. federal law does not apply, by the law of the Commonwealth of
 +Virginia, excluding Virginia's conflict of law provisions.
 +Notwithstanding the foregoing, with regard to derivative works based
 +on Python 1.6.1 that incorporate non-separable material that was
 +previously distributed under the GNU General Public License (GPL), the
 +law of the Commonwealth of Virginia shall govern this License
 +Agreement only as to issues arising under or with respect to
 +Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
 +License Agreement shall be deemed to create any relationship of
 +agency, partnership, or joint venture between CNRI and Licensee.  This
 +License Agreement does not grant permission to use CNRI trademarks or
 +trade name in a trademark sense to endorse or promote products or
 +services of Licensee, or any third party.
 +
 +8. By clicking on the "ACCEPT" button where indicated, or by copying,
 +installing or otherwise using Python 1.6.1, Licensee agrees to be
 +bound by the terms and conditions of this License Agreement.
 +
 +        ACCEPT
 +
 +
 +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
 +--------------------------------------------------
 +
 +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
 +The Netherlands.  All rights reserved.
 +
 +Permission to use, copy, modify, and distribute this software and its
 +documentation for any purpose and without fee is hereby granted,
 +provided that the above copyright notice appear in all copies and that
 +both that copyright notice and this permission notice appear in
 +supporting documentation, and that the name of Stichting Mathematisch
 +Centrum or CWI not be used in advertising or publicity pertaining to
 +distribution of the software without specific, written prior
 +permission.
 +
 +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
 +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
 +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 diff --git a/scripts/argparse.py b/scripts/argparse.py
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/scripts/argparse.py
++++ b/tests/iothread.c
 @@ -XXX,XX +XXX,XX @@
-+# This is a local copy of the standard library argparse module taken from PyPI.
++/*
-+# It is licensed under the Python Software Foundation License.  This is a
++ * Event loop thread implementation for unit tests
-+# fallback for Python 2.6 which does not include this module.  Python 2.7+ and
++ *
-+# 3+ will never load this module because built-in modules are loaded before
++ * Copyright Red Hat Inc., 2013, 2016
-+# anything in sys.path.
++ *
-+#
++ * Authors:
-+# If your script is not located in the same directory as this file, import it
++ *  Stefan Hajnoczi   <stefanha@redhat.com>
-+# like this:
++ *  Paolo Bonzini     <pbonzini@redhat.com>
-+#
++ *
-+#   import os
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+#   import sys
++ * See the COPYING file in the top-level directory.
-+#   sys.path.append(os.path.join(os.path.dirname(__file__), ..., 'scripts'))
++ *
-+#   import argparse
++ */
 +
-+# Author: Steven J. Bethard <steven.bethard@gmail.com>.
++#include "qemu/osdep.h"
-+# Maintainer: Thomas Waldmann <tw@waldmann-edv.de>
++#include "qapi/error.h"
-+
++#include "block/aio.h"
-+"""Command-line parsing library
++#include "qemu/main-loop.h"
-+
++#include "qemu/rcu.h"
-+This module is an optparse-inspired command-line parsing library that:
++#include "iothread.h"
 +
-+    - handles both optional and positional arguments
++struct IOThread {
-+    - produces highly informative usage messages
++    AioContext *ctx;
-+    - supports parsers that dispatch to sub-parsers
++
-+
++    QemuThread thread;
-+The following is a simple usage example that sums integers from the
++    QemuMutex init_done_lock;
-+command-line and writes the result to a file::
++    QemuCond init_done_cond;    /* is thread initialization done? */
-+
++    bool stopping;
-+    parser = argparse.ArgumentParser(
++};
-+        description='sum the integers at the command line')
++
-+    parser.add_argument(
++static __thread IOThread *my_iothread;
-+        'integers', metavar='int', nargs='+', type=int,
++
-+        help='an integer to be summed')
++AioContext *qemu_get_current_aio_context(void)
-+    parser.add_argument(
++{
-+        '--log', default=sys.stdout, type=argparse.FileType('w'),
++    return my_iothread ? my_iothread->ctx : qemu_get_aio_context();
-+        help='the file where the sum should be written')
++}
-+    args = parser.parse_args()
++
-+    args.log.write('%s' % sum(args.integers))
++static void *iothread_run(void *opaque)
-+    args.log.close()
++{
-+
++    IOThread *iothread = opaque;
-+The module contains the following public classes:
++
-+
++    rcu_register_thread();
-+    - ArgumentParser -- The main entry point for command-line parsing. As the
++
-+        example above shows, the add_argument() method is used to populate
++    my_iothread = iothread;
-+        the parser with actions for optional and positional arguments. Then
++    qemu_mutex_lock(&iothread->init_done_lock);
-+        the parse_args() method is invoked to convert the args at the
++    iothread->ctx = aio_context_new(&error_abort);
-+        command-line into an object with attributes.
++    qemu_cond_signal(&iothread->init_done_cond);
-+
++    qemu_mutex_unlock(&iothread->init_done_lock);
-+    - ArgumentError -- The exception raised by ArgumentParser objects when
++
-+        there are errors with the parser's actions. Errors raised while
++    while (!atomic_read(&iothread->stopping)) {
-+        parsing the command-line are caught by ArgumentParser and emitted
++        aio_poll(iothread->ctx, true);
-+        as command-line messages.
++    }
 +
-+    - FileType -- A factory for defining types of files to be created. As the
++    rcu_unregister_thread();
-+        example above shows, instances of FileType are typically passed as
++    return NULL;
-+        the type= argument of add_argument() calls.
++}
 +
-+    - Action -- The base class for parser actions. Typically actions are
++void iothread_join(IOThread *iothread)
-+        selected by passing strings like 'store_true' or 'append_const' to
++{
-+        the action= argument of add_argument(). However, for greater
++    iothread->stopping = true;
-+        customization of ArgumentParser actions, subclasses of Action may
++    aio_notify(iothread->ctx);
-+        be defined and passed as the action= argument.
++    qemu_thread_join(&iothread->thread);
-+
++    qemu_cond_destroy(&iothread->init_done_cond);
-+    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
++    qemu_mutex_destroy(&iothread->init_done_lock);
-+        ArgumentDefaultsHelpFormatter -- Formatter classes which
++    aio_context_unref(iothread->ctx);
-+        may be passed as the formatter_class= argument to the
++    g_free(iothread);
-+        ArgumentParser constructor. HelpFormatter is the default,
++}
-+        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
++
-+        not to change the formatting for help text, and
++IOThread *iothread_new(void)
-+        ArgumentDefaultsHelpFormatter adds information about argument defaults
++{
-+        to the help.
++    IOThread *iothread = g_new0(IOThread, 1);
 +
-+All other classes in this module are considered implementation details.
++    qemu_mutex_init(&iothread->init_done_lock);
-+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
++    qemu_cond_init(&iothread->init_done_cond);
-+considered public as object names -- the API of the formatter objects is
++    qemu_thread_create(&iothread->thread, NULL, iothread_run,
-+still considered an implementation detail.)
++                       iothread, QEMU_THREAD_JOINABLE);
-+"""
++
-+
++    /* Wait for initialization to complete */
-+__version__ = '1.4.0'  # we use our own version number independant of the
++    qemu_mutex_lock(&iothread->init_done_lock);
-+                       # one in stdlib and we release this on pypi.
++    while (iothread->ctx == NULL) {
-+
++        qemu_cond_wait(&iothread->init_done_cond,
-+__external_lib__ = True  # to make sure the tests really test THIS lib,
++                       &iothread->init_done_lock);
-+                         # not the builtin one in Python stdlib
++    }
-+
++    qemu_mutex_unlock(&iothread->init_done_lock);
-+__all__ = [
++    return iothread;
-+    'ArgumentParser',
++}
-+    'ArgumentError',
++
-+    'ArgumentTypeError',
++AioContext *iothread_get_aio_context(IOThread *iothread)
-+    'FileType',
++{
-+    'HelpFormatter',
++    return iothread->ctx;
-+    'ArgumentDefaultsHelpFormatter',
++}
-+    'RawDescriptionHelpFormatter',
+diff --git a/tests/test-aio-multithread.c b/tests/test-aio-multithread.c
-+    'RawTextHelpFormatter',
+new file mode 100644
-+    'Namespace',
+index XXXXXXX..XXXXXXX
-+    'Action',
+--- /dev/null
-+    'ONE_OR_MORE',
++++ b/tests/test-aio-multithread.c
-+    'OPTIONAL',
+@@ -XXX,XX +XXX,XX @@
-+    'PARSER',
++/*
-+    'REMAINDER',
++ * AioContext multithreading tests
-+    'SUPPRESS',
++ *
-+    'ZERO_OR_MORE',
++ * Copyright Red Hat, Inc. 2016
-+]
++ *
-+
++ * Authors:
-+
++ *  Paolo Bonzini    <pbonzini@redhat.com>
-+import copy as _copy
++ *
-+import os as _os
++ * This work is licensed under the terms of the GNU LGPL, version 2 or later.
-+import re as _re
++ * See the COPYING.LIB file in the top-level directory.
-+import sys as _sys
++ */
-+import textwrap as _textwrap
++
-+
++#include "qemu/osdep.h"
-+from gettext import gettext as _
++#include <glib.h>
-+
++#include "block/aio.h"
-+try:
++#include "qapi/error.h"
-+    set
++#include "qemu/coroutine.h"
-+except NameError:
++#include "qemu/thread.h"
-+    # for python < 2.4 compatibility (sets module is there since 2.3):
++#include "qemu/error-report.h"
-+    from sets import Set as set
++#include "iothread.h"
 +
-+try:
++/* AioContext management */
-+    basestring
++
-+except NameError:
++#define NUM_CONTEXTS 5
-+    basestring = str
++
-+
++static IOThread *threads[NUM_CONTEXTS];
-+try:
++static AioContext *ctx[NUM_CONTEXTS];
-+    sorted
++static __thread int id = -1;
-+except NameError:
++
-+    # for python < 2.4 compatibility:
++static QemuEvent done_event;
-+    def sorted(iterable, reverse=False):
++
-+        result = list(iterable)
++/* Run a function synchronously on a remote iothread. */
-+        result.sort()
++
-+        if reverse:
++typedef struct CtxRunData {
-+            result.reverse()
++    QEMUBHFunc *cb;
-+        return result
++    void *arg;
-+
++} CtxRunData;
 +
-+def _callable(obj):
++static void ctx_run_bh_cb(void *opaque)
-+    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
++{
-+
++    CtxRunData *data = opaque;
 +
-+SUPPRESS = '==SUPPRESS=='
++    data->cb(data->arg);
-+
++    qemu_event_set(&done_event);
-+OPTIONAL = '?'
++}
-+ZERO_OR_MORE = '*'
++
-+ONE_OR_MORE = '+'
++static void ctx_run(int i, QEMUBHFunc *cb, void *opaque)
-+PARSER = 'A...'
++{
-+REMAINDER = '...'
++    CtxRunData data = {
-+_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
++        .cb = cb,
-+
++        .arg = opaque
-+# =============================
++    };
-+# Utility functions and classes
++
-+# =============================
++    qemu_event_reset(&done_event);
-+
++    aio_bh_schedule_oneshot(ctx[i], ctx_run_bh_cb, &data);
-+class _AttributeHolder(object):
++    qemu_event_wait(&done_event);
-+    """Abstract base class that provides __repr__.
++}
 +
-+    The __repr__ method returns a string in the format::
++/* Starting the iothreads. */
-+        ClassName(attr=name, attr=name, ...)
++
-+    The attributes are determined either by a class-level attribute,
++static void set_id_cb(void *opaque)
-+    '_kwarg_names', or by inspecting the instance __dict__.
++{
-+    """
++    int *i = opaque;
 +
-+    def __repr__(self):
++    id = *i;
-+        type_name = type(self).__name__
++}
-+        arg_strings = []
++
-+        for arg in self._get_args():
++static void create_aio_contexts(void)
-+            arg_strings.append(repr(arg))
++{
-+        for name, value in self._get_kwargs():
++    int i;
-+            arg_strings.append('%s=%r' % (name, value))
++
-+        return '%s(%s)' % (type_name, ', '.join(arg_strings))
++    for (i = 0; i < NUM_CONTEXTS; i++) {
-+
++        threads[i] = iothread_new();
-+    def _get_kwargs(self):
++        ctx[i] = iothread_get_aio_context(threads[i]);
-+        return sorted(self.__dict__.items())
++    }
 +
-+    def _get_args(self):
++    qemu_event_init(&done_event, false);
-+        return []
++    for (i = 0; i < NUM_CONTEXTS; i++) {
-+
++        ctx_run(i, set_id_cb, &i);
-+
++    }
-+def _ensure_value(namespace, name, value):
++}
-+    if getattr(namespace, name, None) is None:
++
-+        setattr(namespace, name, value)
++/* Stopping the iothreads. */
-+    return getattr(namespace, name)
++
-+
++static void join_aio_contexts(void)
-+
++{
-+# ===============
++    int i;
-+# Formatting Help
++
-+# ===============
++    for (i = 0; i < NUM_CONTEXTS; i++) {
-+
++        aio_context_ref(ctx[i]);
-+class HelpFormatter(object):
++    }
-+    """Formatter for generating usage messages and argument help strings.
++    for (i = 0; i < NUM_CONTEXTS; i++) {
-+
++        iothread_join(threads[i]);
-+    Only the name of this class is considered a public API. All the methods
++    }
-+    provided by the class are considered an implementation detail.
++    for (i = 0; i < NUM_CONTEXTS; i++) {
-+    """
++        aio_context_unref(ctx[i]);
-+
++    }
-+    def __init__(self,
++    qemu_event_destroy(&done_event);
-+                 prog,
++}
-+                 indent_increment=2,
++
-+                 max_help_position=24,
++/* Basic test for the stuff above. */
-+                 width=None):
++
-+
++static void test_lifecycle(void)
-+        # default setting for width
++{
-+        if width is None:
++    create_aio_contexts();
-+            try:
++    join_aio_contexts();
-+                width = int(_os.environ['COLUMNS'])
++}
-+            except (KeyError, ValueError):
++
-+                width = 80
++/* aio_co_schedule test.  */
-+            width -= 2
++
-+
++static Coroutine *to_schedule[NUM_CONTEXTS];
-+        self._prog = prog
++
-+        self._indent_increment = indent_increment
++static bool now_stopping;
-+        self._max_help_position = max_help_position
++
-+        self._width = width
++static int count_retry;
-+
++static int count_here;
-+        self._current_indent = 0
++static int count_other;
-+        self._level = 0
++
-+        self._action_max_length = 0
++static bool schedule_next(int n)
-+
++{
-+        self._root_section = self._Section(self, None)
++    Coroutine *co;
-+        self._current_section = self._root_section
++
-+
++    co = atomic_xchg(&to_schedule[n], NULL);
-+        self._whitespace_matcher = _re.compile(r'\s+')
++    if (!co) {
-+        self._long_break_matcher = _re.compile(r'\n\n\n+')
++        atomic_inc(&count_retry);
-+
++        return false;
-+    # ===============================
++    }
-+    # Section and indentation methods
++
-+    # ===============================
++    if (n == id) {
-+    def _indent(self):
++        atomic_inc(&count_here);
-+        self._current_indent += self._indent_increment
++    } else {
-+        self._level += 1
++        atomic_inc(&count_other);
-+
++    }
-+    def _dedent(self):
++
-+        self._current_indent -= self._indent_increment
++    aio_co_schedule(ctx[n], co);
-+        assert self._current_indent >= 0, 'Indent decreased below 0.'
++    return true;
-+        self._level -= 1
++}
 +
-+    class _Section(object):
++static void finish_cb(void *opaque)
-+
++{
-+        def __init__(self, formatter, parent, heading=None):
++    schedule_next(id);
-+            self.formatter = formatter
++}
-+            self.parent = parent
++
-+            self.heading = heading
++static coroutine_fn void test_multi_co_schedule_entry(void *opaque)
-+            self.items = []
++{
-+
++    g_assert(to_schedule[id] == NULL);
-+        def format_help(self):
++    atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
-+            # format the indented section
++
-+            if self.parent is not None:
++    while (!atomic_mb_read(&now_stopping)) {
-+                self.formatter._indent()
++        int n;
-+            join = self.formatter._join_parts
++
-+            for func, args in self.items:
++        n = g_test_rand_int_range(0, NUM_CONTEXTS);
-+                func(*args)
++        schedule_next(n);
-+            item_help = join([func(*args) for func, args in self.items])
++        qemu_coroutine_yield();
-+            if self.parent is not None:
++
-+                self.formatter._dedent()
++        g_assert(to_schedule[id] == NULL);
-+
++        atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
-+            # return nothing if the section was empty
++    }
-+            if not item_help:
++}
-+                return ''
++
 +
-+            # add the heading if the section was non-empty
++static void test_multi_co_schedule(int seconds)
-+            if self.heading is not SUPPRESS and self.heading is not None:
++{
-+                current_indent = self.formatter._current_indent
++    int i;
-+                heading = '%*s%s:\n' % (current_indent, '', self.heading)
++
-+            else:
++    count_here = count_other = count_retry = 0;
-+                heading = ''
++    now_stopping = false;
 +
-+            # join the section-initial newline, the heading and the help
++    create_aio_contexts();
-+            return join(['\n', heading, item_help, '\n'])
++    for (i = 0; i < NUM_CONTEXTS; i++) {
-+
++        Coroutine *co1 = qemu_coroutine_create(test_multi_co_schedule_entry, NULL);
-+    def _add_item(self, func, args):
++        aio_co_schedule(ctx[i], co1);
-+        self._current_section.items.append((func, args))
++    }
 +
-+    # ========================
++    g_usleep(seconds * 1000000);
-+    # Message building methods
++
-+    # ========================
++    atomic_mb_set(&now_stopping, true);
-+    def start_section(self, heading):
++    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        self._indent()
++        ctx_run(i, finish_cb, NULL);
-+        section = self._Section(self, self._current_section, heading)
++        to_schedule[i] = NULL;
-+        self._add_item(section.format_help, [])
++    }
-+        self._current_section = section
++
-+
++    join_aio_contexts();
-+    def end_section(self):
++    g_test_message("scheduled %d, queued %d, retry %d, total %d\n",
-+        self._current_section = self._current_section.parent
++                  count_other, count_here, count_retry,
-+        self._dedent()
++                  count_here + count_other + count_retry);
-+
++}
-+    def add_text(self, text):
++
-+        if text is not SUPPRESS and text is not None:
++static void test_multi_co_schedule_1(void)
-+            self._add_item(self._format_text, [text])
++{
-+
++    test_multi_co_schedule(1);
-+    def add_usage(self, usage, actions, groups, prefix=None):
++}
-+        if usage is not SUPPRESS:
++
-+            args = usage, actions, groups, prefix
++static void test_multi_co_schedule_10(void)
-+            self._add_item(self._format_usage, args)
++{
-+
++    test_multi_co_schedule(10);
-+    def add_argument(self, action):
++}
-+        if action.help is not SUPPRESS:
++
-+
++/* End of tests.  */
-+            # find all invocations
++
-+            get_invocation = self._format_action_invocation
++int main(int argc, char **argv)
-+            invocations = [get_invocation(action)]
++{
-+            for subaction in self._iter_indented_subactions(action):
++    init_clocks();
-+                invocations.append(get_invocation(subaction))
++
-+
++    g_test_init(&argc, &argv, NULL);
-+            # update the maximum item length
++    g_test_add_func("/aio/multi/lifecycle", test_lifecycle);
-+            invocation_length = max([len(s) for s in invocations])
++    if (g_test_quick()) {
-+            action_length = invocation_length + self._current_indent
++        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
-+            self._action_max_length = max(self._action_max_length,
++    } else {
-+                                          action_length)
++        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
-+
++    }
-+            # add the item to the list
++    return g_test_run();
-+            self._add_item(self._format_action, [action])
++}
-+
+diff --git a/util/async.c b/util/async.c
-+    def add_arguments(self, actions):
+index XXXXXXX..XXXXXXX 100644
-+        for action in actions:
+--- a/util/async.c
-+            self.add_argument(action)
++++ b/util/async.c
-+
+@@ -XXX,XX +XXX,XX @@
-+    # =======================
+ #include "qemu/main-loop.h"
-+    # Help-formatting methods
+ #include "qemu/atomic.h"
-+    # =======================
+ #include "block/raw-aio.h"
-+    def format_help(self):
++#include "qemu/coroutine_int.h"
-+        help = self._root_section.format_help()
++#include "trace.h"
-+        if help:
-+            help = self._long_break_matcher.sub('\n\n', help)
+ /***********************************************************/
-+            help = help.strip('\n') + '\n'
+ /* bottom halves (can be seen as timers which expire ASAP) */
-+        return help
+@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
-+
+     }
-+    def _join_parts(self, part_strings):
+ #endif
-+        return ''.join([part
-+                        for part in part_strings
++    assert(QSLIST_EMPTY(&ctx->scheduled_coroutines));
-+                        if part and part is not SUPPRESS])
++    qemu_bh_delete(ctx->co_schedule_bh);
 +
-+    def _format_usage(self, usage, actions, groups, prefix):
+     qemu_lockcnt_lock(&ctx->list_lock);
-+        if prefix is None:
+     assert(!qemu_lockcnt_count(&ctx->list_lock));
-+            prefix = _('usage: ')
+     while (ctx->first_bh) {
-+
+@@ -XXX,XX +XXX,XX @@ static bool event_notifier_poll(void *opaque)
-+        # if usage is specified, use that
+     return atomic_read(&ctx->notified);
-+        if usage is not None:
+ }
-+            usage = usage % dict(prog=self._prog)
-+
++static void co_schedule_bh_cb(void *opaque)
-+        # if no optionals or positionals are available, usage is just prog
++{
-+        elif usage is None and not actions:
++    AioContext *ctx = opaque;
-+            usage = '%(prog)s' % dict(prog=self._prog)
++    QSLIST_HEAD(, Coroutine) straight, reversed;
 +
-+        # if optionals and positionals are available, calculate usage
++    QSLIST_MOVE_ATOMIC(&reversed, &ctx->scheduled_coroutines);
-+        elif usage is None:
++    QSLIST_INIT(&straight);
-+            prog = '%(prog)s' % dict(prog=self._prog)
++
-+
++    while (!QSLIST_EMPTY(&reversed)) {
-+            # split optionals from positionals
++        Coroutine *co = QSLIST_FIRST(&reversed);
-+            optionals = []
++        QSLIST_REMOVE_HEAD(&reversed, co_scheduled_next);
-+            positionals = []
++        QSLIST_INSERT_HEAD(&straight, co, co_scheduled_next);
-+            for action in actions:
++    }
-+                if action.option_strings:
++
-+                    optionals.append(action)
++    while (!QSLIST_EMPTY(&straight)) {
-+                else:
++        Coroutine *co = QSLIST_FIRST(&straight);
-+                    positionals.append(action)
++        QSLIST_REMOVE_HEAD(&straight, co_scheduled_next);
-+
++        trace_aio_co_schedule_bh_cb(ctx, co);
-+            # build full usage string
++        qemu_coroutine_enter(co);
-+            format = self._format_actions_usage
++    }
-+            action_usage = format(optionals + positionals, groups)
++}
-+            usage = ' '.join([s for s in [prog, action_usage] if s])
++
-+
+ AioContext *aio_context_new(Error **errp)
-+            # wrap the usage parts if it's too long
+ {
-+            text_width = self._width - self._current_indent
+     int ret;
-+            if len(prefix) + len(usage) > text_width:
+@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
-+
+     }
-+                # break usage into wrappable parts
+     g_source_set_can_recurse(&ctx->source, true);
-+                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
+     qemu_lockcnt_init(&ctx->list_lock);
-+                opt_usage = format(optionals, groups)
++
-+                pos_usage = format(positionals, groups)
++    ctx->co_schedule_bh = aio_bh_new(ctx, co_schedule_bh_cb, ctx);
-+                opt_parts = _re.findall(part_regexp, opt_usage)
++    QSLIST_INIT(&ctx->scheduled_coroutines);
-+                pos_parts = _re.findall(part_regexp, pos_usage)
++
-+                assert ' '.join(opt_parts) == opt_usage
+     aio_set_event_notifier(ctx, &ctx->notifier,
-+                assert ' '.join(pos_parts) == pos_usage
+                            false,
-+
+                            (EventNotifierHandler *)
-+                # helper for wrapping lines
+@@ -XXX,XX +XXX,XX @@ fail:
-+                def get_lines(parts, indent, prefix=None):
+     return NULL;
-+                    lines = []
+ }
-+                    line = []
-+                    if prefix is not None:
++void aio_co_schedule(AioContext *ctx, Coroutine *co)
-+                        line_len = len(prefix) - 1
++{
-+                    else:
++    trace_aio_co_schedule(ctx, co);
-+                        line_len = len(indent) - 1
++    QSLIST_INSERT_HEAD_ATOMIC(&ctx->scheduled_coroutines,
-+                    for part in parts:
++                              co, co_scheduled_next);
-+                        if line_len + 1 + len(part) > text_width:
++    qemu_bh_schedule(ctx->co_schedule_bh);
-+                            lines.append(indent + ' '.join(line))
++}
-+                            line = []
++
-+                            line_len = len(indent) - 1
++void aio_co_wake(struct Coroutine *co)
-+                        line.append(part)
++{
-+                        line_len += len(part) + 1
++    AioContext *ctx;
-+                    if line:
++
-+                        lines.append(indent + ' '.join(line))
++    /* Read coroutine before co->ctx.  Matches smp_wmb in
-+                    if prefix is not None:
++     * qemu_coroutine_enter.
-+                        lines[0] = lines[0][len(indent):]
++     */
-+                    return lines
++    smp_read_barrier_depends();
-+
++    ctx = atomic_read(&co->ctx);
-+                # if prog is short, follow it with optionals or positionals
++
-+                if len(prefix) + len(prog) <= 0.75 * text_width:
++    if (ctx != qemu_get_current_aio_context()) {
-+                    indent = ' ' * (len(prefix) + len(prog) + 1)
++        aio_co_schedule(ctx, co);
-+                    if opt_parts:
++        return;
-+                        lines = get_lines([prog] + opt_parts, indent, prefix)
++    }
-+                        lines.extend(get_lines(pos_parts, indent))
++
-+                    elif pos_parts:
++    if (qemu_in_coroutine()) {
-+                        lines = get_lines([prog] + pos_parts, indent, prefix)
++        Coroutine *self = qemu_coroutine_self();
-+                    else:
++        assert(self != co);
-+                        lines = [prog]
++        QSIMPLEQ_INSERT_TAIL(&self->co_queue_wakeup, co, co_queue_next);
-+
++    } else {
-+                # if prog is long, put it on its own line
++        aio_context_acquire(ctx);
-+                else:
++        qemu_coroutine_enter(co);
-+                    indent = ' ' * len(prefix)
++        aio_context_release(ctx);
-+                    parts = opt_parts + pos_parts
++    }
-+                    lines = get_lines(parts, indent)
++}
-+                    if len(lines) > 1:
++
-+                        lines = []
+ void aio_context_ref(AioContext *ctx)
-+                        lines.extend(get_lines(opt_parts, indent))
+ {
-+                        lines.extend(get_lines(pos_parts, indent))
+     g_source_ref(&ctx->source);
-+                    lines = [prog] + lines
+diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
-+
+index XXXXXXX..XXXXXXX 100644
-+                # join lines into usage
+--- a/util/qemu-coroutine.c
-+                usage = '\n'.join(lines)
++++ b/util/qemu-coroutine.c
-+
+@@ -XXX,XX +XXX,XX @@
-+        # prefix with 'usage:'
+ #include "qemu/atomic.h"
-+        return '%s%s\n\n' % (prefix, usage)
+ #include "qemu/coroutine.h"
-+
+ #include "qemu/coroutine_int.h"
-+    def _format_actions_usage(self, actions, groups):
++#include "block/aio.h"
-+        # find group indices and identify actions in groups
-+        group_actions = set()
+ enum {
-+        inserts = {}
+     POOL_BATCH_SIZE = 64,
-+        for group in groups:
+@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_enter(Coroutine *co)
-+            try:
+     }
-+                start = actions.index(group._group_actions[0])
-+            except ValueError:
+     co->caller = self;
-+                continue
++    co->ctx = qemu_get_current_aio_context();
-+            else:
++
-+                end = start + len(group._group_actions)
++    /* Store co->ctx before anything that stores co.  Matches
-+                if actions[start:end] == group._group_actions:
++     * barrier in aio_co_wake.
-+                    for action in group._group_actions:
++     */
-+                        group_actions.add(action)
++    smp_wmb();
-+                    if not group.required:
++
-+                        if start in inserts:
+     ret = qemu_coroutine_switch(self, co, COROUTINE_ENTER);
-+                            inserts[start] += ' ['
-+                        else:
+     qemu_co_queue_run_restart(co);
-+                            inserts[start] = '['
+diff --git a/util/trace-events b/util/trace-events
-+                        inserts[end] = ']'
+index XXXXXXX..XXXXXXX 100644
-+                    else:
+--- a/util/trace-events
-+                        if start in inserts:
++++ b/util/trace-events
-+                            inserts[start] += ' ('
+@@ -XXX,XX +XXX,XX @@ run_poll_handlers_end(void *ctx, bool progress) "ctx %p progress %d"
-+                        else:
+ poll_shrink(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
-+                            inserts[start] = '('
+ poll_grow(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
-+                        inserts[end] = ')'
-+                    for i in range(start + 1, end):
++# util/async.c
-+                        inserts[i] = '|'
++aio_co_schedule(void *ctx, void *co) "ctx %p co %p"
-+
++aio_co_schedule_bh_cb(void *ctx, void *co) "ctx %p co %p"
-+        # collect all actions format strings
++
-+        parts = []
+ # util/thread-pool.c
-+        for i, action in enumerate(actions):
+ 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"
 +            # suppressed arguments are marked with None
 +            # remove | separators for suppressed arguments
 +            if action.help is SUPPRESS:
 +                parts.append(None)
 +                if inserts.get(i) == '|':
 +                    inserts.pop(i)
 +                elif inserts.get(i + 1) == '|':
 +                    inserts.pop(i + 1)
 +
 +            # produce all arg strings
 +            elif not action.option_strings:
 +                part = self._format_args(action, action.dest)
 +
 +                # if it's in a group, strip the outer []
 +                if action in group_actions:
 +                    if part[0] == '[' and part[-1] == ']':
 +                        part = part[1:-1]
 +
 +                # add the action string to the list
 +                parts.append(part)
 +
 +            # produce the first way to invoke the option in brackets
 +            else:
 +                option_string = action.option_strings[0]
 +
 +                # if the Optional doesn't take a value, format is:
 +                #    -s or --long
 +                if action.nargs == 0:
 +                    part = '%s' % option_string
 +
 +                # if the Optional takes a value, format is:
 +                #    -s ARGS or --long ARGS
 +                else:
 +                    default = action.dest.upper()
 +                    args_string = self._format_args(action, default)
 +                    part = '%s %s' % (option_string, args_string)
 +
 +                # make it look optional if it's not required or in a group
 +                if not action.required and action not in group_actions:
 +                    part = '[%s]' % part
 +
 +                # add the action string to the list
 +                parts.append(part)
 +
 +        # insert things at the necessary indices
 +        for i in sorted(inserts, reverse=True):
 +            parts[i:i] = [inserts[i]]
 +
 +        # join all the action items with spaces
 +        text = ' '.join([item for item in parts if item is not None])
 +
 +        # clean up separators for mutually exclusive groups
 +        open = r'[\[(]'
 +        close = r'[\])]'
 +        text = _re.sub(r'(%s) ' % open, r'\1', text)
 +        text = _re.sub(r' (%s)' % close, r'\1', text)
 +        text = _re.sub(r'%s *%s' % (open, close), r'', text)
 +        text = _re.sub(r'\(([^|]*)\)', r'\1', text)
 +        text = text.strip()
 +
 +        # return the text
 +        return text
 +
 +    def _format_text(self, text):
 +        if '%(prog)' in text:
 +            text = text % dict(prog=self._prog)
 +        text_width = self._width - self._current_indent
 +        indent = ' ' * self._current_indent
 +        return self._fill_text(text, text_width, indent) + '\n\n'
 +
 +    def _format_action(self, action):
 +        # determine the required width and the entry label
 +        help_position = min(self._action_max_length + 2,
 +                            self._max_help_position)
 +        help_width = self._width - help_position
 +        action_width = help_position - self._current_indent - 2
 +        action_header = self._format_action_invocation(action)
 +
 +        # ho nelp; start on same line and add a final newline
 +        if not action.help:
 +            tup = self._current_indent, '', action_header
 +            action_header = '%*s%s\n' % tup
 +
 +        # short action name; start on the same line and pad two spaces
 +        elif len(action_header) <= action_width:
 +            tup = self._current_indent, '', action_width, action_header
 +            action_header = '%*s%-*s  ' % tup
 +            indent_first = 0
 +
 +        # long action name; start on the next line
 +        else:
 +            tup = self._current_indent, '', action_header
 +            action_header = '%*s%s\n' % tup
 +            indent_first = help_position
 +
 +        # collect the pieces of the action help
 +        parts = [action_header]
 +
 +        # if there was help for the action, add lines of help text
 +        if action.help:
 +            help_text = self._expand_help(action)
 +            help_lines = self._split_lines(help_text, help_width)
 +            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
 +            for line in help_lines[1:]:
 +                parts.append('%*s%s\n' % (help_position, '', line))
 +
 +        # or add a newline if the description doesn't end with one
 +        elif not action_header.endswith('\n'):
 +            parts.append('\n')
 +
 +        # if there are any sub-actions, add their help as well
 +        for subaction in self._iter_indented_subactions(action):
 +            parts.append(self._format_action(subaction))
 +
 +        # return a single string
 +        return self._join_parts(parts)
 +
 +    def _format_action_invocation(self, action):
 +        if not action.option_strings:
 +            metavar, = self._metavar_formatter(action, action.dest)(1)
 +            return metavar
 +
 +        else:
 +            parts = []
 +
 +            # if the Optional doesn't take a value, format is:
 +            #    -s, --long
 +            if action.nargs == 0:
 +                parts.extend(action.option_strings)
 +
 +            # if the Optional takes a value, format is:
 +            #    -s ARGS, --long ARGS
 +            else:
 +                default = action.dest.upper()
 +                args_string = self._format_args(action, default)
 +                for option_string in action.option_strings:
 +                    parts.append('%s %s' % (option_string, args_string))
 +
 +            return ', '.join(parts)
 +
 +    def _metavar_formatter(self, action, default_metavar):
 +        if action.metavar is not None:
 +            result = action.metavar
 +        elif action.choices is not None:
 +            choice_strs = [str(choice) for choice in action.choices]
 +            result = '{%s}' % ','.join(choice_strs)
 +        else:
 +            result = default_metavar
 +
 +        def format(tuple_size):
 +            if isinstance(result, tuple):
 +                return result
 +            else:
 +                return (result, ) * tuple_size
 +        return format
 +
 +    def _format_args(self, action, default_metavar):
 +        get_metavar = self._metavar_formatter(action, default_metavar)
 +        if action.nargs is None:
 +            result = '%s' % get_metavar(1)
 +        elif action.nargs == OPTIONAL:
 +            result = '[%s]' % get_metavar(1)
 +        elif action.nargs == ZERO_OR_MORE:
 +            result = '[%s [%s ...]]' % get_metavar(2)
 +        elif action.nargs == ONE_OR_MORE:
 +            result = '%s [%s ...]' % get_metavar(2)
 +        elif action.nargs == REMAINDER:
 +            result = '...'
 +        elif action.nargs == PARSER:
 +            result = '%s ...' % get_metavar(1)
 +        else:
 +            formats = ['%s' for _ in range(action.nargs)]
 +            result = ' '.join(formats) % get_metavar(action.nargs)
 +        return result
 +
 +    def _expand_help(self, action):
 +        params = dict(vars(action), prog=self._prog)
 +        for name in list(params):
 +            if params[name] is SUPPRESS:
 +                del params[name]
 +        for name in list(params):
 +            if hasattr(params[name], '__name__'):
 +                params[name] = params[name].__name__
 +        if params.get('choices') is not None:
 +            choices_str = ', '.join([str(c) for c in params['choices']])
 +            params['choices'] = choices_str
 +        return self._get_help_string(action) % params
 +
 +    def _iter_indented_subactions(self, action):
 +        try:
 +            get_subactions = action._get_subactions
 +        except AttributeError:
 +            pass
 +        else:
 +            self._indent()
 +            for subaction in get_subactions():
 +                yield subaction
 +            self._dedent()
 +
 +    def _split_lines(self, text, width):
 +        text = self._whitespace_matcher.sub(' ', text).strip()
 +        return _textwrap.wrap(text, width)
 +
 +    def _fill_text(self, text, width, indent):
 +        text = self._whitespace_matcher.sub(' ', text).strip()
 +        return _textwrap.fill(text, width, initial_indent=indent,
 +                                           subsequent_indent=indent)
 +
 +    def _get_help_string(self, action):
 +        return action.help
 +
 +
 +class RawDescriptionHelpFormatter(HelpFormatter):
 +    """Help message formatter which retains any formatting in descriptions.
 +
 +    Only the name of this class is considered a public API. All the methods
 +    provided by the class are considered an implementation detail.
 +    """
 +
 +    def _fill_text(self, text, width, indent):
 +        return ''.join([indent + line for line in text.splitlines(True)])
 +
 +
 +class RawTextHelpFormatter(RawDescriptionHelpFormatter):
 +    """Help message formatter which retains formatting of all help text.
 +
 +    Only the name of this class is considered a public API. All the methods
 +    provided by the class are considered an implementation detail.
 +    """
 +
 +    def _split_lines(self, text, width):
 +        return text.splitlines()
 +
 +
 +class ArgumentDefaultsHelpFormatter(HelpFormatter):
 +    """Help message formatter which adds default values to argument help.
 +
 +    Only the name of this class is considered a public API. All the methods
 +    provided by the class are considered an implementation detail.
 +    """
 +
 +    def _get_help_string(self, action):
 +        help = action.help
 +        if '%(default)' not in action.help:
 +            if action.default is not SUPPRESS:
 +                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
 +                if action.option_strings or action.nargs in defaulting_nargs:
 +                    help += ' (default: %(default)s)'
 +        return help
 +
 +
 +# =====================
 +# Options and Arguments
 +# =====================
 +
 +def _get_action_name(argument):
 +    if argument is None:
 +        return None
 +    elif argument.option_strings:
 +        return  '/'.join(argument.option_strings)
 +    elif argument.metavar not in (None, SUPPRESS):
 +        return argument.metavar
 +    elif argument.dest not in (None, SUPPRESS):
 +        return argument.dest
 +    else:
 +        return None
 +
 +
 +class ArgumentError(Exception):
 +    """An error from creating or using an argument (optional or positional).
 +
 +    The string value of this exception is the message, augmented with
 +    information about the argument that caused it.
 +    """
 +
 +    def __init__(self, argument, message):
 +        self.argument_name = _get_action_name(argument)
 +        self.message = message
 +
 +    def __str__(self):
 +        if self.argument_name is None:
 +            format = '%(message)s'
 +        else:
 +            format = 'argument %(argument_name)s: %(message)s'
 +        return format % dict(message=self.message,
 +                             argument_name=self.argument_name)
 +
 +
 +class ArgumentTypeError(Exception):
 +    """An error from trying to convert a command line string to a type."""
 +    pass
 +
 +
 +# ==============
 +# Action classes
 +# ==============
 +
 +class Action(_AttributeHolder):
 +    """Information about how to convert command line strings to Python objects.
 +
 +    Action objects are used by an ArgumentParser to represent the information
 +    needed to parse a single argument from one or more strings from the
 +    command line. The keyword arguments to the Action constructor are also
 +    all attributes of Action instances.
 +
 +    Keyword Arguments:
 +
 +        - option_strings -- A list of command-line option strings which
 +            should be associated with this action.
 +
 +        - dest -- The name of the attribute to hold the created object(s)
 +
 +        - nargs -- The number of command-line arguments that should be
 +            consumed. By default, one argument will be consumed and a single
 +            value will be produced.  Other values include:
 +                - N (an integer) consumes N arguments (and produces a list)
 +                - '?' consumes zero or one arguments
 +                - '*' consumes zero or more arguments (and produces a list)
 +                - '+' consumes one or more arguments (and produces a list)
 +            Note that the difference between the default and nargs=1 is that
 +            with the default, a single value will be produced, while with
 +            nargs=1, a list containing a single value will be produced.
 +
 +        - const -- The value to be produced if the option is specified and the
 +            option uses an action that takes no values.
 +
 +        - default -- The value to be produced if the option is not specified.
 +
 +        - type -- The type which the command-line arguments should be converted
 +            to, should be one of 'string', 'int', 'float', 'complex' or a
 +            callable object that accepts a single string argument. If None,
 +            'string' is assumed.
 +
 +        - choices -- A container of values that should be allowed. If not None,
 +            after a command-line argument has been converted to the appropriate
 +            type, an exception will be raised if it is not a member of this
 +            collection.
 +
 +        - required -- True if the action must always be specified at the
 +            command line. This is only meaningful for optional command-line
 +            arguments.
 +
 +        - help -- The help string describing the argument.
 +
 +        - metavar -- The name to be used for the option's argument with the
 +            help string. If None, the 'dest' value will be used as the name.
 +    """
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 nargs=None,
 +                 const=None,
 +                 default=None,
 +                 type=None,
 +                 choices=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        self.option_strings = option_strings
 +        self.dest = dest
 +        self.nargs = nargs
 +        self.const = const
 +        self.default = default
 +        self.type = type
 +        self.choices = choices
 +        self.required = required
 +        self.help = help
 +        self.metavar = metavar
 +
 +    def _get_kwargs(self):
 +        names = [
 +            'option_strings',
 +            'dest',
 +            'nargs',
 +            'const',
 +            'default',
 +            'type',
 +            'choices',
 +            'help',
 +            'metavar',
 +        ]
 +        return [(name, getattr(self, name)) for name in names]
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        raise NotImplementedError(_('.__call__() not defined'))
 +
 +
 +class _StoreAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 nargs=None,
 +                 const=None,
 +                 default=None,
 +                 type=None,
 +                 choices=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        if nargs == 0:
 +            raise ValueError('nargs for store actions must be > 0; if you '
 +                             'have nothing to store, actions such as store '
 +                             'true or store const may be more appropriate')
 +        if const is not None and nargs != OPTIONAL:
 +            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
 +        super(_StoreAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=nargs,
 +            const=const,
 +            default=default,
 +            type=type,
 +            choices=choices,
 +            required=required,
 +            help=help,
 +            metavar=metavar)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        setattr(namespace, self.dest, values)
 +
 +
 +class _StoreConstAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 const,
 +                 default=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        super(_StoreConstAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=0,
 +            const=const,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        setattr(namespace, self.dest, self.const)
 +
 +
 +class _StoreTrueAction(_StoreConstAction):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 default=False,
 +                 required=False,
 +                 help=None):
 +        super(_StoreTrueAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            const=True,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +
 +class _StoreFalseAction(_StoreConstAction):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 default=True,
 +                 required=False,
 +                 help=None):
 +        super(_StoreFalseAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            const=False,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +
 +class _AppendAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 nargs=None,
 +                 const=None,
 +                 default=None,
 +                 type=None,
 +                 choices=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        if nargs == 0:
 +            raise ValueError('nargs for append actions must be > 0; if arg '
 +                             'strings are not supplying the value to append, '
 +                             'the append const action may be more appropriate')
 +        if const is not None and nargs != OPTIONAL:
 +            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
 +        super(_AppendAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=nargs,
 +            const=const,
 +            default=default,
 +            type=type,
 +            choices=choices,
 +            required=required,
 +            help=help,
 +            metavar=metavar)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        items = _copy.copy(_ensure_value(namespace, self.dest, []))
 +        items.append(values)
 +        setattr(namespace, self.dest, items)
 +
 +
 +class _AppendConstAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 const,
 +                 default=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        super(_AppendConstAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=0,
 +            const=const,
 +            default=default,
 +            required=required,
 +            help=help,
 +            metavar=metavar)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        items = _copy.copy(_ensure_value(namespace, self.dest, []))
 +        items.append(self.const)
 +        setattr(namespace, self.dest, items)
 +
 +
 +class _CountAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 default=None,
 +                 required=False,
 +                 help=None):
 +        super(_CountAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=0,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        new_count = _ensure_value(namespace, self.dest, 0) + 1
 +        setattr(namespace, self.dest, new_count)
 +
 +
 +class _HelpAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest=SUPPRESS,
 +                 default=SUPPRESS,
 +                 help=None):
 +        super(_HelpAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            default=default,
 +            nargs=0,
 +            help=help)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        parser.print_help()
 +        parser.exit()
 +
 +
 +class _VersionAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 version=None,
 +                 dest=SUPPRESS,
 +                 default=SUPPRESS,
 +                 help="show program's version number and exit"):
 +        super(_VersionAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            default=default,
 +            nargs=0,
 +            help=help)
 +        self.version = version
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        version = self.version
 +        if version is None:
 +            version = parser.version
 +        formatter = parser._get_formatter()
 +        formatter.add_text(version)
 +        parser.exit(message=formatter.format_help())
 +
 +
 +class _SubParsersAction(Action):
 +
 +    class _ChoicesPseudoAction(Action):
 +
 +        def __init__(self, name, aliases, help):
 +            metavar = dest = name
 +            if aliases:
 +                metavar += ' (%s)' % ', '.join(aliases)
 +            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
 +            sup.__init__(option_strings=[], dest=dest, help=help,
 +                        metavar=metavar)
 +
 +    def __init__(self,
 +                 option_strings,
 +                 prog,
 +                 parser_class,
 +                 dest=SUPPRESS,
 +                 help=None,
 +                 metavar=None):
 +
 +        self._prog_prefix = prog
 +        self._parser_class = parser_class
 +        self._name_parser_map = {}
 +        self._choices_actions = []
 +
 +        super(_SubParsersAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=PARSER,
 +            choices=self._name_parser_map,
 +            help=help,
 +            metavar=metavar)
 +
 +    def add_parser(self, name, **kwargs):
 +        # set prog from the existing prefix
 +        if kwargs.get('prog') is None:
 +            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
 +
 +        aliases = kwargs.pop('aliases', ())
 +
 +        # create a pseudo-action to hold the choice help
 +        if 'help' in kwargs:
 +            help = kwargs.pop('help')
 +            choice_action = self._ChoicesPseudoAction(name, aliases, help)
 +            self._choices_actions.append(choice_action)
 +
 +        # create the parser and add it to the map
 +        parser = self._parser_class(**kwargs)
 +        self._name_parser_map[name] = parser
 +
 +        # make parser available under aliases also
 +        for alias in aliases:
 +            self._name_parser_map[alias] = parser
 +
 +        return parser
 +
 +    def _get_subactions(self):
 +        return self._choices_actions
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        parser_name = values[0]
 +        arg_strings = values[1:]
 +
 +        # set the parser name if requested
 +        if self.dest is not SUPPRESS:
 +            setattr(namespace, self.dest, parser_name)
 +
 +        # select the parser
 +        try:
 +            parser = self._name_parser_map[parser_name]
 +        except KeyError:
 +            tup = parser_name, ', '.join(self._name_parser_map)
 +            msg = _('unknown parser %r (choices: %s)' % tup)
 +            raise ArgumentError(self, msg)
 +
 +        # parse all the remaining options into the namespace
 +        # store any unrecognized options on the object, so that the top
 +        # level parser can decide what to do with them
 +        namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
 +        if arg_strings:
 +            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
 +            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
 +
 +
 +# ==============
 +# Type classes
 +# ==============
 +
 +class FileType(object):
 +    """Factory for creating file object types
 +
 +    Instances of FileType are typically passed as type= arguments to the
 +    ArgumentParser add_argument() method.
 +
 +    Keyword Arguments:
 +        - mode -- A string indicating how the file is to be opened. Accepts the
 +            same values as the builtin open() function.
 +        - bufsize -- The file's desired buffer size. Accepts the same values as
 +            the builtin open() function.
 +    """
 +
 +    def __init__(self, mode='r', bufsize=None):
 +        self._mode = mode
 +        self._bufsize = bufsize
 +
 +    def __call__(self, string):
 +        # the special argument "-" means sys.std{in,out}
 +        if string == '-':
 +            if 'r' in self._mode:
 +                return _sys.stdin
 +            elif 'w' in self._mode:
 +                return _sys.stdout
 +            else:
 +                msg = _('argument "-" with mode %r' % self._mode)
 +                raise ValueError(msg)
 +
 +        try:
 +            # all other arguments are used as file names
 +            if self._bufsize:
 +                return open(string, self._mode, self._bufsize)
 +            else:
 +                return open(string, self._mode)
 +        except IOError:
 +            err = _sys.exc_info()[1]
 +            message = _("can't open '%s': %s")
 +            raise ArgumentTypeError(message % (string, err))
 +
 +    def __repr__(self):
 +        args = [self._mode, self._bufsize]
 +        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
 +        return '%s(%s)' % (type(self).__name__, args_str)
 +
 +# ===========================
 +# Optional and Positional Parsing
 +# ===========================
 +
 +class Namespace(_AttributeHolder):
 +    """Simple object for storing attributes.
 +
 +    Implements equality by attribute names and values, and provides a simple
 +    string representation.
 +    """
 +
 +    def __init__(self, **kwargs):
 +        for name in kwargs:
 +            setattr(self, name, kwargs[name])
 +
 +    __hash__ = None
 +
 +    def __eq__(self, other):
 +        return vars(self) == vars(other)
 +
 +    def __ne__(self, other):
 +        return not (self == other)
 +
 +    def __contains__(self, key):
 +        return key in self.__dict__
 +
 +
 +class _ActionsContainer(object):
 +
 +    def __init__(self,
 +                 description,
 +                 prefix_chars,
 +                 argument_default,
 +                 conflict_handler):
 +        super(_ActionsContainer, self).__init__()
 +
 +        self.description = description
 +        self.argument_default = argument_default
 +        self.prefix_chars = prefix_chars
 +        self.conflict_handler = conflict_handler
 +
 +        # set up registries
 +        self._registries = {}
 +
 +        # register actions
 +        self.register('action', None, _StoreAction)
 +        self.register('action', 'store', _StoreAction)
 +        self.register('action', 'store_const', _StoreConstAction)
 +        self.register('action', 'store_true', _StoreTrueAction)
 +        self.register('action', 'store_false', _StoreFalseAction)
 +        self.register('action', 'append', _AppendAction)
 +        self.register('action', 'append_const', _AppendConstAction)
 +        self.register('action', 'count', _CountAction)
 +        self.register('action', 'help', _HelpAction)
 +        self.register('action', 'version', _VersionAction)
 +        self.register('action', 'parsers', _SubParsersAction)
 +
 +        # raise an exception if the conflict handler is invalid
 +        self._get_handler()
 +
 +        # action storage
 +        self._actions = []
 +        self._option_string_actions = {}
 +
 +        # groups
 +        self._action_groups = []
 +        self._mutually_exclusive_groups = []
 +
 +        # defaults storage
 +        self._defaults = {}
 +
 +        # determines whether an "option" looks like a negative number
 +        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
 +
 +        # whether or not there are any optionals that look like negative
 +        # numbers -- uses a list so it can be shared and edited
 +        self._has_negative_number_optionals = []
 +
 +    # ====================
 +    # Registration methods
 +    # ====================
 +    def register(self, registry_name, value, object):
 +        registry = self._registries.setdefault(registry_name, {})
 +        registry[value] = object
 +
 +    def _registry_get(self, registry_name, value, default=None):
 +        return self._registries[registry_name].get(value, default)
 +
 +    # ==================================
 +    # Namespace default accessor methods
 +    # ==================================
 +    def set_defaults(self, **kwargs):
 +        self._defaults.update(kwargs)
 +
 +        # if these defaults match any existing arguments, replace
 +        # the previous default on the object with the new one
 +        for action in self._actions:
 +            if action.dest in kwargs:
 +                action.default = kwargs[action.dest]
 +
 +    def get_default(self, dest):
 +        for action in self._actions:
 +            if action.dest == dest and action.default is not None:
 +                return action.default
 +        return self._defaults.get(dest, None)
 +
 +
 +    # =======================
 +    # Adding argument actions
 +    # =======================
 +    def add_argument(self, *args, **kwargs):
 +        """
 +        add_argument(dest, ..., name=value, ...)
 +        add_argument(option_string, option_string, ..., name=value, ...)
 +        """
 +
 +        # if no positional args are supplied or only one is supplied and
 +        # it doesn't look like an option string, parse a positional
 +        # argument
 +        chars = self.prefix_chars
 +        if not args or len(args) == 1 and args[0][0] not in chars:
 +            if args and 'dest' in kwargs:
 +                raise ValueError('dest supplied twice for positional argument')
 +            kwargs = self._get_positional_kwargs(*args, **kwargs)
 +
 +        # otherwise, we're adding an optional argument
 +        else:
 +            kwargs = self._get_optional_kwargs(*args, **kwargs)
 +
 +        # if no default was supplied, use the parser-level default
 +        if 'default' not in kwargs:
 +            dest = kwargs['dest']
 +            if dest in self._defaults:
 +                kwargs['default'] = self._defaults[dest]
 +            elif self.argument_default is not None:
 +                kwargs['default'] = self.argument_default
 +
 +        # create the action object, and add it to the parser
 +        action_class = self._pop_action_class(kwargs)
 +        if not _callable(action_class):
 +            raise ValueError('unknown action "%s"' % action_class)
 +        action = action_class(**kwargs)
 +
 +        # raise an error if the action type is not callable
 +        type_func = self._registry_get('type', action.type, action.type)
 +        if not _callable(type_func):
 +            raise ValueError('%r is not callable' % type_func)
 +
 +        return self._add_action(action)
 +
 +    def add_argument_group(self, *args, **kwargs):
 +        group = _ArgumentGroup(self, *args, **kwargs)
 +        self._action_groups.append(group)
 +        return group
 +
 +    def add_mutually_exclusive_group(self, **kwargs):
 +        group = _MutuallyExclusiveGroup(self, **kwargs)
 +        self._mutually_exclusive_groups.append(group)
 +        return group
 +
 +    def _add_action(self, action):
 +        # resolve any conflicts
 +        self._check_conflict(action)
 +
 +        # add to actions list
 +        self._actions.append(action)
 +        action.container = self
 +
 +        # index the action by any option strings it has
 +        for option_string in action.option_strings:
 +            self._option_string_actions[option_string] = action
 +
 +        # set the flag if any option strings look like negative numbers
 +        for option_string in action.option_strings:
 +            if self._negative_number_matcher.match(option_string):
 +                if not self._has_negative_number_optionals:
 +                    self._has_negative_number_optionals.append(True)
 +
 +        # return the created action
 +        return action
 +
 +    def _remove_action(self, action):
 +        self._actions.remove(action)
 +
 +    def _add_container_actions(self, container):
 +        # collect groups by titles
 +        title_group_map = {}
 +        for group in self._action_groups:
 +            if group.title in title_group_map:
 +                msg = _('cannot merge actions - two groups are named %r')
 +                raise ValueError(msg % (group.title))
 +            title_group_map[group.title] = group
 +
 +        # map each action to its group
 +        group_map = {}
 +        for group in container._action_groups:
 +
 +            # if a group with the title exists, use that, otherwise
 +            # create a new group matching the container's group
 +            if group.title not in title_group_map:
 +                title_group_map[group.title] = self.add_argument_group(
 +                    title=group.title,
 +                    description=group.description,
 +                    conflict_handler=group.conflict_handler)
 +
 +            # map the actions to their new group
 +            for action in group._group_actions:
 +                group_map[action] = title_group_map[group.title]
 +
 +        # add container's mutually exclusive groups
 +        # NOTE: if add_mutually_exclusive_group ever gains title= and
 +        # description= then this code will need to be expanded as above
 +        for group in container._mutually_exclusive_groups:
 +            mutex_group = self.add_mutually_exclusive_group(
 +                required=group.required)
 +
 +            # map the actions to their new mutex group
 +            for action in group._group_actions:
 +                group_map[action] = mutex_group
 +
 +        # add all actions to this container or their group
 +        for action in container._actions:
 +            group_map.get(action, self)._add_action(action)
 +
 +    def _get_positional_kwargs(self, dest, **kwargs):
 +        # make sure required is not specified
 +        if 'required' in kwargs:
 +            msg = _("'required' is an invalid argument for positionals")
 +            raise TypeError(msg)
 +
 +        # mark positional arguments as required if at least one is
 +        # always required
 +        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
 +            kwargs['required'] = True
 +        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
 +            kwargs['required'] = True
 +
 +        # return the keyword arguments with no option strings
 +        return dict(kwargs, dest=dest, option_strings=[])
 +
 +    def _get_optional_kwargs(self, *args, **kwargs):
 +        # determine short and long option strings
 +        option_strings = []
 +        long_option_strings = []
 +        for option_string in args:
 +            # error on strings that don't start with an appropriate prefix
 +            if not option_string[0] in self.prefix_chars:
 +                msg = _('invalid option string %r: '
 +                        'must start with a character %r')
 +                tup = option_string, self.prefix_chars
 +                raise ValueError(msg % tup)
 +
 +            # strings starting with two prefix characters are long options
 +            option_strings.append(option_string)
 +            if option_string[0] in self.prefix_chars:
 +                if len(option_string) > 1:
 +                    if option_string[1] in self.prefix_chars:
 +                        long_option_strings.append(option_string)
 +
 +        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
 +        dest = kwargs.pop('dest', None)
 +        if dest is None:
 +            if long_option_strings:
 +                dest_option_string = long_option_strings[0]
 +            else:
 +                dest_option_string = option_strings[0]
 +            dest = dest_option_string.lstrip(self.prefix_chars)
 +            if not dest:
 +                msg = _('dest= is required for options like %r')
 +                raise ValueError(msg % option_string)
 +            dest = dest.replace('-', '_')
 +
 +        # return the updated keyword arguments
 +        return dict(kwargs, dest=dest, option_strings=option_strings)
 +
 +    def _pop_action_class(self, kwargs, default=None):
 +        action = kwargs.pop('action', default)
 +        return self._registry_get('action', action, action)
 +
 +    def _get_handler(self):
 +        # determine function from conflict handler string
 +        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
 +        try:
 +            return getattr(self, handler_func_name)
 +        except AttributeError:
 +            msg = _('invalid conflict_resolution value: %r')
 +            raise ValueError(msg % self.conflict_handler)
 +
 +    def _check_conflict(self, action):
 +
 +        # find all options that conflict with this option
 +        confl_optionals = []
 +        for option_string in action.option_strings:
 +            if option_string in self._option_string_actions:
 +                confl_optional = self._option_string_actions[option_string]
 +                confl_optionals.append((option_string, confl_optional))
 +
 +        # resolve any conflicts
 +        if confl_optionals:
 +            conflict_handler = self._get_handler()
 +            conflict_handler(action, confl_optionals)
 +
 +    def _handle_conflict_error(self, action, conflicting_actions):
 +        message = _('conflicting option string(s): %s')
 +        conflict_string = ', '.join([option_string
 +                                     for option_string, action
 +                                     in conflicting_actions])
 +        raise ArgumentError(action, message % conflict_string)
 +
 +    def _handle_conflict_resolve(self, action, conflicting_actions):
 +
 +        # remove all conflicting options
 +        for option_string, action in conflicting_actions:
 +
 +            # remove the conflicting option
 +            action.option_strings.remove(option_string)
 +            self._option_string_actions.pop(option_string, None)
 +
 +            # if the option now has no option string, remove it from the
 +            # container holding it
 +            if not action.option_strings:
 +                action.container._remove_action(action)
 +
 +
 +class _ArgumentGroup(_ActionsContainer):
 +
 +    def __init__(self, container, title=None, description=None, **kwargs):
 +        # add any missing keyword arguments by checking the container
 +        update = kwargs.setdefault
 +        update('conflict_handler', container.conflict_handler)
 +        update('prefix_chars', container.prefix_chars)
 +        update('argument_default', container.argument_default)
 +        super_init = super(_ArgumentGroup, self).__init__
 +        super_init(description=description, **kwargs)
 +
 +        # group attributes
 +        self.title = title
 +        self._group_actions = []
 +
 +        # share most attributes with the container
 +        self._registries = container._registries
 +        self._actions = container._actions
 +        self._option_string_actions = container._option_string_actions
 +        self._defaults = container._defaults
 +        self._has_negative_number_optionals = \
 +            container._has_negative_number_optionals
 +
 +    def _add_action(self, action):
 +        action = super(_ArgumentGroup, self)._add_action(action)
 +        self._group_actions.append(action)
 +        return action
 +
 +    def _remove_action(self, action):
 +        super(_ArgumentGroup, self)._remove_action(action)
 +        self._group_actions.remove(action)
 +
 +
 +class _MutuallyExclusiveGroup(_ArgumentGroup):
 +
 +    def __init__(self, container, required=False):
 +        super(_MutuallyExclusiveGroup, self).__init__(container)
 +        self.required = required
 +        self._container = container
 +
 +    def _add_action(self, action):
 +        if action.required:
 +            msg = _('mutually exclusive arguments must be optional')
 +            raise ValueError(msg)
 +        action = self._container._add_action(action)
 +        self._group_actions.append(action)
 +        return action
 +
 +    def _remove_action(self, action):
 +        self._container._remove_action(action)
 +        self._group_actions.remove(action)
 +
 +
 +class ArgumentParser(_AttributeHolder, _ActionsContainer):
 +    """Object for parsing command line strings into Python objects.
 +
 +    Keyword Arguments:
 +        - prog -- The name of the program (default: sys.argv[0])
 +        - usage -- A usage message (default: auto-generated from arguments)
 +        - description -- A description of what the program does
 +        - epilog -- Text following the argument descriptions
 +        - parents -- Parsers whose arguments should be copied into this one
 +        - formatter_class -- HelpFormatter class for printing help messages
 +        - prefix_chars -- Characters that prefix optional arguments
 +        - fromfile_prefix_chars -- Characters that prefix files containing
 +            additional arguments
 +        - argument_default -- The default value for all arguments
 +        - conflict_handler -- String indicating how to handle conflicts
 +        - add_help -- Add a -h/-help option
 +    """
 +
 +    def __init__(self,
 +                 prog=None,
 +                 usage=None,
 +                 description=None,
 +                 epilog=None,
 +                 version=None,
 +                 parents=[],
 +                 formatter_class=HelpFormatter,
 +                 prefix_chars='-',
 +                 fromfile_prefix_chars=None,
 +                 argument_default=None,
 +                 conflict_handler='error',
 +                 add_help=True):
 +
 +        if version is not None:
 +            import warnings
 +            warnings.warn(
 +                """The "version" argument to ArgumentParser is deprecated. """
 +                """Please use """
 +                """"add_argument(..., action='version', version="N", ...)" """
 +                """instead""", DeprecationWarning)
 +
 +        superinit = super(ArgumentParser, self).__init__
 +        superinit(description=description,
 +                  prefix_chars=prefix_chars,
 +                  argument_default=argument_default,
 +                  conflict_handler=conflict_handler)
 +
 +        # default setting for prog
 +        if prog is None:
 +            prog = _os.path.basename(_sys.argv[0])
 +
 +        self.prog = prog
 +        self.usage = usage
 +        self.epilog = epilog
 +        self.version = version
 +        self.formatter_class = formatter_class
 +        self.fromfile_prefix_chars = fromfile_prefix_chars
 +        self.add_help = add_help
 +
 +        add_group = self.add_argument_group
 +        self._positionals = add_group(_('positional arguments'))
 +        self._optionals = add_group(_('optional arguments'))
 +        self._subparsers = None
 +
 +        # register types
 +        def identity(string):
 +            return string
 +        self.register('type', None, identity)
 +
 +        # add help and version arguments if necessary
 +        # (using explicit default to override global argument_default)
 +        if '-' in prefix_chars:
 +            default_prefix = '-'
 +        else:
 +            default_prefix = prefix_chars[0]
 +        if self.add_help:
 +            self.add_argument(
 +                default_prefix+'h', default_prefix*2+'help',
 +                action='help', default=SUPPRESS,
 +                help=_('show this help message and exit'))
 +        if self.version:
 +            self.add_argument(
 +                default_prefix+'v', default_prefix*2+'version',
 +                action='version', default=SUPPRESS,
 +                version=self.version,
 +                help=_("show program's version number and exit"))
 +
 +        # add parent arguments and defaults
 +        for parent in parents:
 +            self._add_container_actions(parent)
 +            try:
 +                defaults = parent._defaults
 +            except AttributeError:
 +                pass
 +            else:
 +                self._defaults.update(defaults)
 +
 +    # =======================
 +    # Pretty __repr__ methods
 +    # =======================
 +    def _get_kwargs(self):
 +        names = [
 +            'prog',
 +            'usage',
 +            'description',
 +            'version',
 +            'formatter_class',
 +            'conflict_handler',
 +            'add_help',
 +        ]
 +        return [(name, getattr(self, name)) for name in names]
 +
 +    # ==================================
 +    # Optional/Positional adding methods
 +    # ==================================
 +    def add_subparsers(self, **kwargs):
 +        if self._subparsers is not None:
 +            self.error(_('cannot have multiple subparser arguments'))
 +
 +        # add the parser class to the arguments if it's not present
 +        kwargs.setdefault('parser_class', type(self))
 +
 +        if 'title' in kwargs or 'description' in kwargs:
 +            title = _(kwargs.pop('title', 'subcommands'))
 +            description = _(kwargs.pop('description', None))
 +            self._subparsers = self.add_argument_group(title, description)
 +        else:
 +            self._subparsers = self._positionals
 +
 +        # prog defaults to the usage message of this parser, skipping
 +        # optional arguments and with no "usage:" prefix
 +        if kwargs.get('prog') is None:
 +            formatter = self._get_formatter()
 +            positionals = self._get_positional_actions()
 +            groups = self._mutually_exclusive_groups
 +            formatter.add_usage(self.usage, positionals, groups, '')
 +            kwargs['prog'] = formatter.format_help().strip()
 +
 +        # create the parsers action and add it to the positionals list
 +        parsers_class = self._pop_action_class(kwargs, 'parsers')
 +        action = parsers_class(option_strings=[], **kwargs)
 +        self._subparsers._add_action(action)
 +
 +        # return the created parsers action
 +        return action
 +
 +    def _add_action(self, action):
 +        if action.option_strings:
 +            self._optionals._add_action(action)
 +        else:
 +            self._positionals._add_action(action)
 +        return action
 +
 +    def _get_optional_actions(self):
 +        return [action
 +                for action in self._actions
 +                if action.option_strings]
 +
 +    def _get_positional_actions(self):
 +        return [action
 +                for action in self._actions
 +                if not action.option_strings]
 +
 +    # =====================================
 +    # Command line argument parsing methods
 +    # =====================================
 +    def parse_args(self, args=None, namespace=None):
 +        args, argv = self.parse_known_args(args, namespace)
 +        if argv:
 +            msg = _('unrecognized arguments: %s')
 +            self.error(msg % ' '.join(argv))
 +        return args
 +
 +    def parse_known_args(self, args=None, namespace=None):
 +        # args default to the system args
 +        if args is None:
 +            args = _sys.argv[1:]
 +
 +        # default Namespace built from parser defaults
 +        if namespace is None:
 +            namespace = Namespace()
 +
 +        # add any action defaults that aren't present
 +        for action in self._actions:
 +            if action.dest is not SUPPRESS:
 +                if not hasattr(namespace, action.dest):
 +                    if action.default is not SUPPRESS:
 +                        setattr(namespace, action.dest, action.default)
 +
 +        # add any parser defaults that aren't present
 +        for dest in self._defaults:
 +            if not hasattr(namespace, dest):
 +                setattr(namespace, dest, self._defaults[dest])
 +
 +        # parse the arguments and exit if there are any errors
 +        try:
 +            namespace, args = self._parse_known_args(args, namespace)
 +            if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
 +                args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
 +                delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
 +            return namespace, args
 +        except ArgumentError:
 +            err = _sys.exc_info()[1]
 +            self.error(str(err))
 +
 +    def _parse_known_args(self, arg_strings, namespace):
 +        # replace arg strings that are file references
 +        if self.fromfile_prefix_chars is not None:
 +            arg_strings = self._read_args_from_files(arg_strings)
 +
 +        # map all mutually exclusive arguments to the other arguments
 +        # they can't occur with
 +        action_conflicts = {}
 +        for mutex_group in self._mutually_exclusive_groups:
 +            group_actions = mutex_group._group_actions
 +            for i, mutex_action in enumerate(mutex_group._group_actions):
 +                conflicts = action_conflicts.setdefault(mutex_action, [])
 +                conflicts.extend(group_actions[:i])
 +                conflicts.extend(group_actions[i + 1:])
 +
 +        # find all option indices, and determine the arg_string_pattern
 +        # which has an 'O' if there is an option at an index,
 +        # an 'A' if there is an argument, or a '-' if there is a '--'
 +        option_string_indices = {}
 +        arg_string_pattern_parts = []
 +        arg_strings_iter = iter(arg_strings)
 +        for i, arg_string in enumerate(arg_strings_iter):
 +
 +            # all args after -- are non-options
 +            if arg_string == '--':
 +                arg_string_pattern_parts.append('-')
 +                for arg_string in arg_strings_iter:
 +                    arg_string_pattern_parts.append('A')
 +
 +            # otherwise, add the arg to the arg strings
 +            # and note the index if it was an option
 +            else:
 +                option_tuple = self._parse_optional(arg_string)
 +                if option_tuple is None:
 +                    pattern = 'A'
 +                else:
 +                    option_string_indices[i] = option_tuple
 +                    pattern = 'O'
 +                arg_string_pattern_parts.append(pattern)
 +
 +        # join the pieces together to form the pattern
 +        arg_strings_pattern = ''.join(arg_string_pattern_parts)
 +
 +        # converts arg strings to the appropriate and then takes the action
 +        seen_actions = set()
 +        seen_non_default_actions = set()
 +
 +        def take_action(action, argument_strings, option_string=None):
 +            seen_actions.add(action)
 +            argument_values = self._get_values(action, argument_strings)
 +
 +            # error if this argument is not allowed with other previously
 +            # seen arguments, assuming that actions that use the default
 +            # value don't really count as "present"
 +            if argument_values is not action.default:
 +                seen_non_default_actions.add(action)
 +                for conflict_action in action_conflicts.get(action, []):
 +                    if conflict_action in seen_non_default_actions:
 +                        msg = _('not allowed with argument %s')
 +                        action_name = _get_action_name(conflict_action)
 +                        raise ArgumentError(action, msg % action_name)
 +
 +            # take the action if we didn't receive a SUPPRESS value
 +            # (e.g. from a default)
 +            if argument_values is not SUPPRESS:
 +                action(self, namespace, argument_values, option_string)
 +
 +        # function to convert arg_strings into an optional action
 +        def consume_optional(start_index):
 +
 +            # get the optional identified at this index
 +            option_tuple = option_string_indices[start_index]
 +            action, option_string, explicit_arg = option_tuple
 +
 +            # identify additional optionals in the same arg string
 +            # (e.g. -xyz is the same as -x -y -z if no args are required)
 +            match_argument = self._match_argument
 +            action_tuples = []
 +            while True:
 +
 +                # if we found no optional action, skip it
 +                if action is None:
 +                    extras.append(arg_strings[start_index])
 +                    return start_index + 1
 +
 +                # if there is an explicit argument, try to match the
 +                # optional's string arguments to only this
 +                if explicit_arg is not None:
 +                    arg_count = match_argument(action, 'A')
 +
 +                    # if the action is a single-dash option and takes no
 +                    # arguments, try to parse more single-dash options out
 +                    # of the tail of the option string
 +                    chars = self.prefix_chars
 +                    if arg_count == 0 and option_string[1] not in chars:
 +                        action_tuples.append((action, [], option_string))
 +                        char = option_string[0]
 +                        option_string = char + explicit_arg[0]
 +                        new_explicit_arg = explicit_arg[1:] or None
 +                        optionals_map = self._option_string_actions
 +                        if option_string in optionals_map:
 +                            action = optionals_map[option_string]
 +                            explicit_arg = new_explicit_arg
 +                        else:
 +                            msg = _('ignored explicit argument %r')
 +                            raise ArgumentError(action, msg % explicit_arg)
 +
 +                    # if the action expect exactly one argument, we've
 +                    # successfully matched the option; exit the loop
 +                    elif arg_count == 1:
 +                        stop = start_index + 1
 +                        args = [explicit_arg]
 +                        action_tuples.append((action, args, option_string))
 +                        break
 +
 +                    # error if a double-dash option did not use the
 +                    # explicit argument
 +                    else:
 +                        msg = _('ignored explicit argument %r')
 +                        raise ArgumentError(action, msg % explicit_arg)
 +
 +                # if there is no explicit argument, try to match the
 +                # optional's string arguments with the following strings
 +                # if successful, exit the loop
 +                else:
 +                    start = start_index + 1
 +                    selected_patterns = arg_strings_pattern[start:]
 +                    arg_count = match_argument(action, selected_patterns)
 +                    stop = start + arg_count
 +                    args = arg_strings[start:stop]
 +                    action_tuples.append((action, args, option_string))
 +                    break
 +
 +            # add the Optional to the list and return the index at which
 +            # the Optional's string args stopped
 +            assert action_tuples
 +            for action, args, option_string in action_tuples:
 +                take_action(action, args, option_string)
 +            return stop
 +
 +        # the list of Positionals left to be parsed; this is modified
 +        # by consume_positionals()
 +        positionals = self._get_positional_actions()
 +
 +        # function to convert arg_strings into positional actions
 +        def consume_positionals(start_index):
 +            # match as many Positionals as possible
 +            match_partial = self._match_arguments_partial
 +            selected_pattern = arg_strings_pattern[start_index:]
 +            arg_counts = match_partial(positionals, selected_pattern)
 +
 +            # slice off the appropriate arg strings for each Positional
 +            # and add the Positional and its args to the list
 +            for action, arg_count in zip(positionals, arg_counts):
 +                args = arg_strings[start_index: start_index + arg_count]
 +                start_index += arg_count
 +                take_action(action, args)
 +
 +            # slice off the Positionals that we just parsed and return the
 +            # index at which the Positionals' string args stopped
 +            positionals[:] = positionals[len(arg_counts):]
 +            return start_index
 +
 +        # consume Positionals and Optionals alternately, until we have
 +        # passed the last option string
 +        extras = []
 +        start_index = 0
 +        if option_string_indices:
 +            max_option_string_index = max(option_string_indices)
 +        else:
 +            max_option_string_index = -1
 +        while start_index <= max_option_string_index:
 +
 +            # consume any Positionals preceding the next option
 +            next_option_string_index = min([
 +                index
 +                for index in option_string_indices
 +                if index >= start_index])
 +            if start_index != next_option_string_index:
 +                positionals_end_index = consume_positionals(start_index)
 +
 +                # only try to parse the next optional if we didn't consume
 +                # the option string during the positionals parsing
 +                if positionals_end_index > start_index:
 +                    start_index = positionals_end_index
 +                    continue
 +                else:
 +                    start_index = positionals_end_index
 +
 +            # if we consumed all the positionals we could and we're not
 +            # at the index of an option string, there were extra arguments
 +            if start_index not in option_string_indices:
 +                strings = arg_strings[start_index:next_option_string_index]
 +                extras.extend(strings)
 +                start_index = next_option_string_index
 +
 +            # consume the next optional and any arguments for it
 +            start_index = consume_optional(start_index)
 +
 +        # consume any positionals following the last Optional
 +        stop_index = consume_positionals(start_index)
 +
 +        # if we didn't consume all the argument strings, there were extras
 +        extras.extend(arg_strings[stop_index:])
 +
 +        # if we didn't use all the Positional objects, there were too few
 +        # arg strings supplied.
 +        if positionals:
 +            self.error(_('too few arguments'))
 +
 +        # make sure all required actions were present, and convert defaults.
 +        for action in self._actions:
 +            if action not in seen_actions:
 +                if action.required:
 +                    name = _get_action_name(action)
 +                    self.error(_('argument %s is required') % name)
 +                else:
 +                    # Convert action default now instead of doing it before
 +                    # parsing arguments to avoid calling convert functions
 +                    # twice (which may fail) if the argument was given, but
 +                    # only if it was defined already in the namespace
 +                    if (action.default is not None and
 +                            isinstance(action.default, basestring) and
 +                            hasattr(namespace, action.dest) and
 +                            action.default is getattr(namespace, action.dest)):
 +                        setattr(namespace, action.dest,
 +                                self._get_value(action, action.default))
 +
 +        # make sure all required groups had one option present
 +        for group in self._mutually_exclusive_groups:
 +            if group.required:
 +                for action in group._group_actions:
 +                    if action in seen_non_default_actions:
 +                        break
 +
 +                # if no actions were used, report the error
 +                else:
 +                    names = [_get_action_name(action)
 +                             for action in group._group_actions
 +                             if action.help is not SUPPRESS]
 +                    msg = _('one of the arguments %s is required')
 +                    self.error(msg % ' '.join(names))
 +
 +        # return the updated namespace and the extra arguments
 +        return namespace, extras
 +
 +    def _read_args_from_files(self, arg_strings):
 +        # expand arguments referencing files
 +        new_arg_strings = []
 +        for arg_string in arg_strings:
 +
 +            # for regular arguments, just add them back into the list
 +            if arg_string[0] not in self.fromfile_prefix_chars:
 +                new_arg_strings.append(arg_string)
 +
 +            # replace arguments referencing files with the file content
 +            else:
 +                try:
 +                    args_file = open(arg_string[1:])
 +                    try:
 +                        arg_strings = []
 +                        for arg_line in args_file.read().splitlines():
 +                            for arg in self.convert_arg_line_to_args(arg_line):
 +                                arg_strings.append(arg)
 +                        arg_strings = self._read_args_from_files(arg_strings)
 +                        new_arg_strings.extend(arg_strings)
 +                    finally:
 +                        args_file.close()
 +                except IOError:
 +                    err = _sys.exc_info()[1]
 +                    self.error(str(err))
 +
 +        # return the modified argument list
 +        return new_arg_strings
 +
 +    def convert_arg_line_to_args(self, arg_line):
 +        return [arg_line]
 +
 +    def _match_argument(self, action, arg_strings_pattern):
 +        # match the pattern for this action to the arg strings
 +        nargs_pattern = self._get_nargs_pattern(action)
 +        match = _re.match(nargs_pattern, arg_strings_pattern)
 +
 +        # raise an exception if we weren't able to find a match
 +        if match is None:
 +            nargs_errors = {
 +                None: _('expected one argument'),
 +                OPTIONAL: _('expected at most one argument'),
 +                ONE_OR_MORE: _('expected at least one argument'),
 +            }
 +            default = _('expected %s argument(s)') % action.nargs
 +            msg = nargs_errors.get(action.nargs, default)
 +            raise ArgumentError(action, msg)
 +
 +        # return the number of arguments matched
 +        return len(match.group(1))
 +
 +    def _match_arguments_partial(self, actions, arg_strings_pattern):
 +        # progressively shorten the actions list by slicing off the
 +        # final actions until we find a match
 +        result = []
 +        for i in range(len(actions), 0, -1):
 +            actions_slice = actions[:i]
 +            pattern = ''.join([self._get_nargs_pattern(action)
 +                               for action in actions_slice])
 +            match = _re.match(pattern, arg_strings_pattern)
 +            if match is not None:
 +                result.extend([len(string) for string in match.groups()])
 +                break
 +
 +        # return the list of arg string counts
 +        return result
 +
 +    def _parse_optional(self, arg_string):
 +        # if it's an empty string, it was meant to be a positional
 +        if not arg_string:
 +            return None
 +
 +        # if it doesn't start with a prefix, it was meant to be positional
 +        if not arg_string[0] in self.prefix_chars:
 +            return None
 +
 +        # if the option string is present in the parser, return the action
 +        if arg_string in self._option_string_actions:
 +            action = self._option_string_actions[arg_string]
 +            return action, arg_string, None
 +
 +        # if it's just a single character, it was meant to be positional
 +        if len(arg_string) == 1:
 +            return None
 +
 +        # if the option string before the "=" is present, return the action
 +        if '=' in arg_string:
 +            option_string, explicit_arg = arg_string.split('=', 1)
 +            if option_string in self._option_string_actions:
 +                action = self._option_string_actions[option_string]
 +                return action, option_string, explicit_arg
 +
 +        # search through all possible prefixes of the option string
 +        # and all actions in the parser for possible interpretations
 +        option_tuples = self._get_option_tuples(arg_string)
 +
 +        # if multiple actions match, the option string was ambiguous
 +        if len(option_tuples) > 1:
 +            options = ', '.join([option_string
 +                for action, option_string, explicit_arg in option_tuples])
 +            tup = arg_string, options
 +            self.error(_('ambiguous option: %s could match %s') % tup)
 +
 +        # if exactly one action matched, this segmentation is good,
 +        # so return the parsed action
 +        elif len(option_tuples) == 1:
 +            option_tuple, = option_tuples
 +            return option_tuple
 +
 +        # if it was not found as an option, but it looks like a negative
 +        # number, it was meant to be positional
 +        # unless there are negative-number-like options
 +        if self._negative_number_matcher.match(arg_string):
 +            if not self._has_negative_number_optionals:
 +                return None
 +
 +        # if it contains a space, it was meant to be a positional
 +        if ' ' in arg_string:
 +            return None
 +
 +        # it was meant to be an optional but there is no such option
 +        # in this parser (though it might be a valid option in a subparser)
 +        return None, arg_string, None
 +
 +    def _get_option_tuples(self, option_string):
 +        result = []
 +
 +        # option strings starting with two prefix characters are only
 +        # split at the '='
 +        chars = self.prefix_chars
 +        if option_string[0] in chars and option_string[1] in chars:
 +            if '=' in option_string:
 +                option_prefix, explicit_arg = option_string.split('=', 1)
 +            else:
 +                option_prefix = option_string
 +                explicit_arg = None
 +            for option_string in self._option_string_actions:
 +                if option_string.startswith(option_prefix):
 +                    action = self._option_string_actions[option_string]
 +                    tup = action, option_string, explicit_arg
 +                    result.append(tup)
 +
 +        # single character options can be concatenated with their arguments
 +        # but multiple character options always have to have their argument
 +        # separate
 +        elif option_string[0] in chars and option_string[1] not in chars:
 +            option_prefix = option_string
 +            explicit_arg = None
 +            short_option_prefix = option_string[:2]
 +            short_explicit_arg = option_string[2:]
 +
 +            for option_string in self._option_string_actions:
 +                if option_string == short_option_prefix:
 +                    action = self._option_string_actions[option_string]
 +                    tup = action, option_string, short_explicit_arg
 +                    result.append(tup)
 +                elif option_string.startswith(option_prefix):
 +                    action = self._option_string_actions[option_string]
 +                    tup = action, option_string, explicit_arg
 +                    result.append(tup)
 +
 +        # shouldn't ever get here
 +        else:
 +            self.error(_('unexpected option string: %s') % option_string)
 +
 +        # return the collected option tuples
 +        return result
 +
 +    def _get_nargs_pattern(self, action):
 +        # in all examples below, we have to allow for '--' args
 +        # which are represented as '-' in the pattern
 +        nargs = action.nargs
 +
 +        # the default (None) is assumed to be a single argument
 +        if nargs is None:
 +            nargs_pattern = '(-*A-*)'
 +
 +        # allow zero or one arguments
 +        elif nargs == OPTIONAL:
 +            nargs_pattern = '(-*A?-*)'
 +
 +        # allow zero or more arguments
 +        elif nargs == ZERO_OR_MORE:
 +            nargs_pattern = '(-*[A-]*)'
 +
 +        # allow one or more arguments
 +        elif nargs == ONE_OR_MORE:
 +            nargs_pattern = '(-*A[A-]*)'
 +
 +        # allow any number of options or arguments
 +        elif nargs == REMAINDER:
 +            nargs_pattern = '([-AO]*)'
 +
 +        # allow one argument followed by any number of options or arguments
 +        elif nargs == PARSER:
 +            nargs_pattern = '(-*A[-AO]*)'
 +
 +        # all others should be integers
 +        else:
 +            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
 +
 +        # if this is an optional action, -- is not allowed
 +        if action.option_strings:
 +            nargs_pattern = nargs_pattern.replace('-*', '')
 +            nargs_pattern = nargs_pattern.replace('-', '')
 +
 +        # return the pattern
 +        return nargs_pattern
 +
 +    # ========================
 +    # Value conversion methods
 +    # ========================
 +    def _get_values(self, action, arg_strings):
 +        # for everything but PARSER args, strip out '--'
 +        if action.nargs not in [PARSER, REMAINDER]:
 +            arg_strings = [s for s in arg_strings if s != '--']
 +
 +        # optional argument produces a default when not present
 +        if not arg_strings and action.nargs == OPTIONAL:
 +            if action.option_strings:
 +                value = action.const
 +            else:
 +                value = action.default
 +            if isinstance(value, basestring):
 +                value = self._get_value(action, value)
 +                self._check_value(action, value)
 +
 +        # when nargs='*' on a positional, if there were no command-line
 +        # args, use the default if it is anything other than None
 +        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
 +              not action.option_strings):
 +            if action.default is not None:
 +                value = action.default
 +            else:
 +                value = arg_strings
 +            self._check_value(action, value)
 +
 +        # single argument or optional argument produces a single value
 +        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
 +            arg_string, = arg_strings
 +            value = self._get_value(action, arg_string)
 +            self._check_value(action, value)
 +
 +        # REMAINDER arguments convert all values, checking none
 +        elif action.nargs == REMAINDER:
 +            value = [self._get_value(action, v) for v in arg_strings]
 +
 +        # PARSER arguments convert all values, but check only the first
 +        elif action.nargs == PARSER:
 +            value = [self._get_value(action, v) for v in arg_strings]
 +            self._check_value(action, value[0])
 +
 +        # all other types of nargs produce a list
 +        else:
 +            value = [self._get_value(action, v) for v in arg_strings]
 +            for v in value:
 +                self._check_value(action, v)
 +
 +        # return the converted value
 +        return value
 +
 +    def _get_value(self, action, arg_string):
 +        type_func = self._registry_get('type', action.type, action.type)
 +        if not _callable(type_func):
 +            msg = _('%r is not callable')
 +            raise ArgumentError(action, msg % type_func)
 +
 +        # convert the value to the appropriate type
 +        try:
 +            result = type_func(arg_string)
 +
 +        # ArgumentTypeErrors indicate errors
 +        except ArgumentTypeError:
 +            name = getattr(action.type, '__name__', repr(action.type))
 +            msg = str(_sys.exc_info()[1])
 +            raise ArgumentError(action, msg)
 +
 +        # TypeErrors or ValueErrors also indicate errors
 +        except (TypeError, ValueError):
 +            name = getattr(action.type, '__name__', repr(action.type))
 +            msg = _('invalid %s value: %r')
 +            raise ArgumentError(action, msg % (name, arg_string))
 +
 +        # return the converted value
 +        return result
 +
 +    def _check_value(self, action, value):
 +        # converted value must be one of the choices (if specified)
 +        if action.choices is not None and value not in action.choices:
 +            tup = value, ', '.join(map(repr, action.choices))
 +            msg = _('invalid choice: %r (choose from %s)') % tup
 +            raise ArgumentError(action, msg)
 +
 +    # =======================
 +    # Help-formatting methods
 +    # =======================
 +    def format_usage(self):
 +        formatter = self._get_formatter()
 +        formatter.add_usage(self.usage, self._actions,
 +                            self._mutually_exclusive_groups)
 +        return formatter.format_help()
 +
 +    def format_help(self):
 +        formatter = self._get_formatter()
 +
 +        # usage
 +        formatter.add_usage(self.usage, self._actions,
 +                            self._mutually_exclusive_groups)
 +
 +        # description
 +        formatter.add_text(self.description)
 +
 +        # positionals, optionals and user-defined groups
 +        for action_group in self._action_groups:
 +            formatter.start_section(action_group.title)
 +            formatter.add_text(action_group.description)
 +            formatter.add_arguments(action_group._group_actions)
 +            formatter.end_section()
 +
 +        # epilog
 +        formatter.add_text(self.epilog)
 +
 +        # determine help from format above
 +        return formatter.format_help()
 +
 +    def format_version(self):
 +        import warnings
 +        warnings.warn(
 +            'The format_version method is deprecated -- the "version" '
 +            'argument to ArgumentParser is no longer supported.',
 +            DeprecationWarning)
 +        formatter = self._get_formatter()
 +        formatter.add_text(self.version)
 +        return formatter.format_help()
 +
 +    def _get_formatter(self):
 +        return self.formatter_class(prog=self.prog)
 +
 +    # =====================
 +    # Help-printing methods
 +    # =====================
 +    def print_usage(self, file=None):
 +        if file is None:
 +            file = _sys.stdout
 +        self._print_message(self.format_usage(), file)
 +
 +    def print_help(self, file=None):
 +        if file is None:
 +            file = _sys.stdout
 +        self._print_message(self.format_help(), file)
 +
 +    def print_version(self, file=None):
 +        import warnings
 +        warnings.warn(
 +            'The print_version method is deprecated -- the "version" '
 +            'argument to ArgumentParser is no longer supported.',
 +            DeprecationWarning)
 +        self._print_message(self.format_version(), file)
 +
 +    def _print_message(self, message, file=None):
 +        if message:
 +            if file is None:
 +                file = _sys.stderr
 +            file.write(message)
 +
 +    # ===============
 +    # Exiting methods
 +    # ===============
 +    def exit(self, status=0, message=None):
 +        if message:
 +            self._print_message(message, _sys.stderr)
 +        _sys.exit(status)
 +
 +    def error(self, message):
 +        """error(message: string)
 +
 +        Prints a usage message incorporating the message to stderr and
 +        exits.
 +
 +        If you override this in a subclass, it should not return -- it
 +        should either exit or raise an exception.
 +        """
 +        self.print_usage(_sys.stderr)
 +        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
 --
-.13.5
+.9.3

-New patch
+[Qemu-devel] [PULL v2 03/24] block-backend: allow blk_prw from coroutine context
+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

-New patch
+[Qemu-devel] [PULL v2 04/24] test-thread-pool: use generic AioContext infrastructure
+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 +++---------
+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;
+ }
+--
+.9.3

-New patch
+[Qemu-devel] [PULL v2 05/24] io: add methods to set I/O handlers on AioContext
+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 +++++++++++
 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,
 --
 .9.3

-New patch
+[Qemu-devel] [PULL v2 06/24] io: make qio_channel_yield aware of AioContexts
+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

-New patch
+[Qemu-devel] [PULL v2 07/24] nbd: convert to use qio_channel_yield
+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 for-2.10 13/15] tests: migration/guestperf Python 2.6 argparse compatibility
+[Qemu-devel] [PULL v2 08/24] coroutine-lock: reschedule coroutine on the AioContext it was running on
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+From: Paolo Bonzini <pbonzini@redhat.com>
 import argparse.
-Cc: Daniel P. Berrange <berrange@redhat.com>
+As a small step towards the introduction of multiqueue, we want
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+coroutines to remain on the same AioContext that started them,
-Acked-by: John Snow <jsnow@redhat.com>
+unless they are moved explicitly with e.g. aio_co_schedule.  This patch
-Acked-by: Fam Zheng <famz@redhat.com>
+avoids that coroutines switch AioContext when they use a CoMutex.
-Message-id: 20170825155732.15665-4-stefanha@redhat.com
+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>
 ---
- tests/migration/guestperf/shell.py | 8 +++++---
+ util/qemu-coroutine-lock.c | 5 ++---
-file changed, 5 insertions(+), 3 deletions(-)
+ util/trace-events          | 1 -
 files changed, 2 insertions(+), 4 deletions(-)
-diff --git a/tests/migration/guestperf/shell.py b/tests/migration/guestperf/shell.py
+diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/migration/guestperf/shell.py
+--- a/util/qemu-coroutine-lock.c
-+++ b/tests/migration/guestperf/shell.py
++++ b/util/qemu-coroutine-lock.c
 @@ -XXX,XX +XXX,XX @@
- #
+ #include "qemu/coroutine.h"
+ #include "qemu/coroutine_int.h"
+ #include "qemu/queue.h"
--import argparse
++#include "block/aio.h"
--import fnmatch
+ #include "trace.h"
- import os
- import os.path
+ void qemu_co_queue_init(CoQueue *queue)
--import platform
+@@ -XXX,XX +XXX,XX @@ void qemu_co_queue_run_restart(Coroutine *co)
- import sys
-+sys.path.append(os.path.join(os.path.dirname(__file__),
+ static bool qemu_co_queue_do_restart(CoQueue *queue, bool single)
-+                             '..', '..', '..', 'scripts'))
+ {
-+import argparse
+-    Coroutine *self = qemu_coroutine_self();
-+import fnmatch
+     Coroutine *next;
-+import platform
+     if (QSIMPLEQ_EMPTY(&queue->entries)) {
- from guestperf.hardware import Hardware
+@@ -XXX,XX +XXX,XX @@ static bool qemu_co_queue_do_restart(CoQueue *queue, bool single)
- from guestperf.engine import Engine
      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"
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 09/15] oslib-posix: Print errors before aborting on qemu_alloc_stack()
+[Qemu-devel] [PULL v2 09/24] blkdebug: reschedule coroutine on the AioContext it is running on
-From: Eduardo Habkost <ehabkost@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-If QEMU is running on a system that's out of memory and mmap()
+Keep the coroutine on the same AioContext.  Without this change,
-fails, QEMU aborts with no error message at all, making it hard
+there would be a race between yielding the coroutine and reentering it.
-to debug the reason for the failure.
+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.
-Add perror() calls that will print error information before
+While doing the change, replace custom bottom half with aio_co_schedule.
 aborting.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+Reviewed-by: Fam Zheng <famz@redhat.com>
-Tested-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20170829212053.6003-1-ehabkost@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>
 ---
- util/oslib-posix.c | 2 ++
+ block/blkdebug.c | 9 +--------
-file changed, 2 insertions(+)
+file changed, 1 insertion(+), 8 deletions(-)
-diff --git a/util/oslib-posix.c b/util/oslib-posix.c
+diff --git a/block/blkdebug.c b/block/blkdebug.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/oslib-posix.c
+--- a/block/blkdebug.c
-+++ b/util/oslib-posix.c
++++ b/block/blkdebug.c
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+@@ -XXX,XX +XXX,XX @@ out:
-     ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
+     return ret;
-                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ }
-     if (ptr == MAP_FAILED) {
-+        perror("failed to allocate memory for stack");
+-static void error_callback_bh(void *opaque)
-         abort();
+-{
 -    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)
      }
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+     if (!immediately) {
-     guardpage = ptr;
+-        aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), error_callback_bh,
- #endif
+-                                qemu_coroutine_self());
-     if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
++        aio_co_schedule(qemu_get_current_aio_context(), qemu_coroutine_self());
-+        perror("failed to set up stack guard page");
+         qemu_coroutine_yield();
          abort();
      }
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 08/15] throttle: Test the valid range of config values
+[Qemu-devel] [PULL v2 10/24] qed: introduce qed_aio_start_io and qed_aio_next_io_cb
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+qed_aio_start_io and qed_aio_next_io will not have to acquire/release
-Message-id: a57dd6274e1b6dc9c28769fec4c7ea543be5c5e3.1503580370.git.berto@igalia.com
+the AioContext, while qed_aio_next_io_cb will.  Split the functionality
 and gain a little type-safety in the process.
 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-11-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/test-throttle.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ block/qed.c | 39 +++++++++++++++++++++++++--------------
-file changed, 77 insertions(+)
+file changed, 25 insertions(+), 14 deletions(-)
-diff --git a/tests/test-throttle.c b/tests/test-throttle.c
+diff --git a/block/qed.c b/block/qed.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-throttle.c
+--- a/block/qed.c
-+++ b/tests/test-throttle.c
++++ b/block/qed.c
-@@ -XXX,XX +XXX,XX @@ static void test_is_valid(void)
+@@ -XXX,XX +XXX,XX @@ static CachedL2Table *qed_new_l2_table(BDRVQEDState *s)
-     test_is_valid_for_value(1, true);
+     return l2_table;
  }
-+static void test_ranges(void)
+-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)
 +{
-+    int i;
++    qed_aio_next_io(acb, 0);
 +
 +    for (i = 0; i < BUCKETS_COUNT; i++) {
 +        LeakyBucket *b = &cfg.buckets[i];
 +        throttle_config_init(&cfg);
 +
 +        /* avg = 0 means throttling is disabled, but the config is valid */
 +        b->avg = 0;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +        g_assert(!throttle_enabled(&cfg));
 +
 +        /* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
 +        b->avg = 1;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = THROTTLE_VALUE_MAX;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = THROTTLE_VALUE_MAX;
 +        b->max = THROTTLE_VALUE_MAX;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        /* Values over THROTTLE_VALUE_MAX are not allowed */
 +        b->avg = THROTTLE_VALUE_MAX + 1;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = THROTTLE_VALUE_MAX;
 +        b->max = THROTTLE_VALUE_MAX + 1;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        /* burst_length must be between 1 and THROTTLE_VALUE_MAX */
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = 0;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = 1;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = THROTTLE_VALUE_MAX;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = THROTTLE_VALUE_MAX + 1;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        /* burst_length * max cannot exceed THROTTLE_VALUE_MAX */
 +        b->avg = 1;
 +        b->max = 2;
 +        b->burst_length = THROTTLE_VALUE_MAX / 2;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 3;
 +        b->burst_length = THROTTLE_VALUE_MAX / 2;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = THROTTLE_VALUE_MAX;
 +        b->burst_length = 1;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = THROTTLE_VALUE_MAX;
 +        b->burst_length = 2;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +    }
 +}
 +
- static void test_max_is_missing_limit(void)
++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)
  {
-     int i;
+@@ -XXX,XX +XXX,XX @@ static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)
-@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-     g_test_add_func("/throttle/config/enabled",     test_enabled);
+     acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);
-     g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
+     if (acb) {
-     g_test_add_func("/throttle/config/is_valid",    test_is_valid);
+-        qed_aio_next_io(acb, 0);
-+    g_test_add_func("/throttle/config/ranges",      test_ranges);
++        qed_aio_start_io(acb);
-     g_test_add_func("/throttle/config/max",         test_max_is_missing_limit);
+     }
-     g_test_add_func("/throttle/config/iops_size",
+ }
-                     test_iops_size_is_missing_limit);
@@ -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;
  }
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 12/15] docker.py: Python 2.6 argparse compatibility
+[Qemu-devel] [PULL v2 11/24] aio: push aio_context_acquire/release down to dispatching
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+From: Paolo Bonzini <pbonzini@redhat.com>
 import argparse.
-Cc: Fam Zheng <famz@redhat.com>
+The AioContext data structures are now protected by list_lock and/or
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+they are walked with FOREACH_RCU primitives.  There is no need anymore
-Acked-by: John Snow <jsnow@redhat.com>
+to acquire the AioContext for the entire duration of aio_dispatch.
-Acked-by: Fam Zheng <famz@redhat.com>
+Instead, just acquire it before and after invoking the callbacks.
-Message-id: 20170825155732.15665-3-stefanha@redhat.com
+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>
 ---
- tests/docker/docker.py | 4 +++-
+ util/aio-posix.c | 25 +++++++++++--------------
-file changed, 3 insertions(+), 1 deletion(-)
+ util/aio-win32.c | 15 +++++++--------
  util/async.c     |  2 ++
 files changed, 20 insertions(+), 22 deletions(-)
-diff --git a/tests/docker/docker.py b/tests/docker/docker.py
+diff --git a/util/aio-posix.c b/util/aio-posix.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/docker/docker.py
+--- a/util/aio-posix.c
-+++ b/tests/docker/docker.py
++++ b/util/aio-posix.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
+             (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
- import os
+             aio_node_check(ctx, node->is_external) &&
- import sys
+             node->io_read) {
-+sys.path.append(os.path.join(os.path.dirname(__file__),
++            aio_context_acquire(ctx);
-+                             '..', '..', 'scripts'))
+             node->io_read(node->opaque);
-+import argparse
++            aio_context_release(ctx);
- import subprocess
- import json
+             /* aio_notify() does not count as progress */
- import hashlib
+             if (node->opaque != &ctx->notifier) {
- import atexit
+@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
- import uuid
+             (revents & (G_IO_OUT | G_IO_ERR)) &&
--import argparse
+             aio_node_check(ctx, node->is_external) &&
- import tempfile
+             node->io_write) {
- import re
++            aio_context_acquire(ctx);
- import signal
+             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;
 --
-.13.5
+.9.3

-New patch
+[Qemu-devel] [PULL v2 12/24] block: explicitly acquire aiocontext in timers that need it
+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 +-
 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,
 --
 .9.3

-[Qemu-devel] [PULL for-2.10 05/15] throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
+[Qemu-devel] [PULL v2 13/24] block: explicitly acquire aiocontext in callbacks that need it
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-The throttling code can change internally the value of bkt->max if it
+This covers both file descriptor callbacks and polling callbacks,
-hasn't been set by the user. The problem with this is that if we want
+since they execute related code.
 to retrieve the original value we have to undo this change first. This
 is ugly and unnecessary: this patch removes the throttle_fix_bucket()
 and throttle_unfix_bucket() functions completely and moves the logic
 to throttle_compute_wait().
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Message-id: 5b0b9e1ac6eb208d709eddc7b09e7669a523bff3.1503580370.git.berto@igalia.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>
 ---
- util/throttle.c | 62 +++++++++++++++++++++------------------------------------
+ block/curl.c          | 16 +++++++++++++---
-file changed, 23 insertions(+), 39 deletions(-)
+ 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 |  7 +++++++
  util/aio-posix.c      |  7 -------
  util/aio-win32.c      |  6 ------
 files changed, 68 insertions(+), 55 deletions(-)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/block/curl.c b/block/curl.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/block/curl.c
-+++ b/util/throttle.c
++++ b/block/curl.c
-@@ -XXX,XX +XXX,XX @@ static int64_t throttle_do_compute_wait(double limit, double extra)
+@@ -XXX,XX +XXX,XX @@ static void curl_multi_check_completion(BDRVCURLState *s)
- int64_t throttle_compute_wait(LeakyBucket *bkt)
+     }
- {
+ }
-     double extra; /* the number of extra units blocking the io */
-+    double bucket_size;   /* I/O before throttling to bkt->avg */
+-static void curl_multi_do(void *arg)
-+    double burst_bucket_size; /* Before throttling to bkt->max */
++static void curl_multi_do_locked(CURLState *s)
+ {
-     if (!bkt->avg) {
+-    CURLState *s = (CURLState *)arg;
-         return 0;
+     CURLSocket *socket, *next_socket;
-     }
+     int running;
+     int r;
--    /* If the bucket is full then we have to wait */
+@@ -XXX,XX +XXX,XX @@ static void curl_multi_do(void *arg)
--    extra = bkt->level - bkt->max * bkt->burst_length;
+     }
-+    if (!bkt->max) {
+ }
-+        /* If bkt->max is 0 we still want to allow short bursts of I/O
-+         * from the guest, otherwise every other request will be throttled
++static void curl_multi_do(void *arg)
-+         * and performance will suffer considerably. */
++{
-+        bucket_size = bkt->avg / 10;
++    CURLState *s = (CURLState *)arg;
-+        burst_bucket_size = 0;
++
-+    } else {
++    aio_context_acquire(s->s->aio_context);
-+        /* If we have a burst limit then we have to wait until all I/O
++    curl_multi_do_locked(s);
-+         * at burst rate has finished before throttling to bkt->avg */
++    aio_context_release(s->s->aio_context);
-+        bucket_size = bkt->max * bkt->burst_length;
++}
-+        burst_bucket_size = bkt->max / 10;
++
-+    }
+ static void curl_multi_read(void *arg)
-+
+ {
-+    /* If the main bucket is full then we have to wait */
+     CURLState *s = (CURLState *)arg;
-+    extra = bkt->level - bucket_size;
-     if (extra > 0) {
+-    curl_multi_do(arg);
-         return throttle_do_compute_wait(bkt->avg, extra);
++    aio_context_acquire(s->s->aio_context);
-     }
++    curl_multi_do_locked(s);
+     curl_multi_check_completion(s->s);
--    /* If the bucket is not full yet we have to make sure that we
++    aio_context_release(s->s->aio_context);
--     * fulfill the goal of bkt->max units per second. */
+ }
-+    /* If the main bucket is not full yet we still have to check the
-+     * burst bucket in order to enforce the burst limit */
+ static void curl_multi_timeout_do(void *arg)
-     if (bkt->burst_length > 1) {
+diff --git a/block/iscsi.c b/block/iscsi.c
--        /* We use 1/10 of the max value to smooth the throttling.
+index XXXXXXX..XXXXXXX 100644
--         * See throttle_fix_bucket() for more details. */
+--- a/block/iscsi.c
--        extra = bkt->burst_level - bkt->max / 10;
++++ b/block/iscsi.c
-+        extra = bkt->burst_level - burst_bucket_size;
+@@ -XXX,XX +XXX,XX @@ iscsi_process_read(void *arg)
-         if (extra > 0) {
+     IscsiLun *iscsilun = arg;
-             return throttle_do_compute_wait(bkt->max, extra);
+     struct iscsi_context *iscsi = iscsilun->iscsi;
-         }
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
++    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;
  }
--/* fix bucket parameters */
+diff --git a/block/nfs.c b/block/nfs.c
--static void throttle_fix_bucket(LeakyBucket *bkt)
+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)
 -{
--    double min;
+-    Coroutine *co = opaque;
 -
--    /* zero bucket level */
+-    qemu_coroutine_enter(co);
 -    bkt->level = bkt->burst_level = 0;
 -
 -    /* If bkt->max is 0 we still want to allow short bursts of I/O
 -     * from the guest, otherwise every other request will be throttled
 -     * and performance will suffer considerably. */
 -    min = bkt->avg / 10;
 -    if (bkt->avg && !bkt->max) {
 -        bkt->max = min;
 -    }
 -}
 -
--/* undo internal bucket parameter changes (see throttle_fix_bucket()) */
+ typedef struct SheepdogReqCo {
--static void throttle_unfix_bucket(LeakyBucket *bkt)
+     int sockfd;
--{
+     BlockDriverState *bs;
--    if (bkt->max < bkt->avg) {
+@@ -XXX,XX +XXX,XX @@ typedef struct SheepdogReqCo {
--        bkt->max = 0;
+     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);
 -}
 -
- /* Used to configure the throttle
+-static coroutine_fn void clear_fd_handler(BDRVSSHState *s,
-  *
+-                                          BlockDriverState *bs)
-  * @ts: the throttle state we are working on
+-{
-@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
+-    DPRINTF("s->sock=%d", s->sock);
+-    aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
-     ts->cfg = *cfg;
+-                       false, NULL, NULL, NULL, NULL);
+-}
 +    /* Zero bucket level */
      for (i = 0; i < BUCKETS_COUNT; i++) {
 -        throttle_fix_bucket(&ts->cfg.buckets[i]);
 +        ts->cfg.buckets[i].level = 0;
 +        ts->cfg.buckets[i].burst_level = 0;
      }
      ts->previous_leak = qemu_clock_get_ns(clock_type);
@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
   */
  void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
  {
 -    int i;
 -
-     *cfg = ts->cfg;
+-/* 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 @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
      MultiReqBuffer mrb = {};
      bool progress = false;
 +    aio_context_acquire(blk_get_aio_context(s->blk));
      blk_io_plug(s->blk);
      do {
@@ -XXX,XX +XXX,XX @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
      }
      blk_io_unplug(s->blk);
 +    aio_context_release(blk_get_aio_context(s->blk));
      return progress;
  }
 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 @@ bool virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq)
      VirtIOSCSIReq *req;
      bool progress = false;
 +    virtio_scsi_acquire(s);
      while ((req = virtio_scsi_pop_req(s, vq))) {
          progress = true;
          virtio_scsi_handle_ctrl_req(s, req);
      }
 +    virtio_scsi_release(s);
      return progress;
  }
@@ -XXX,XX +XXX,XX @@ bool 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 @@ bool 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);
      return progress;
  }
@@ -XXX,XX +XXX,XX @@ out:
  bool 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);
          return true;
      }
 +    virtio_scsi_release(s);
      return false;
  }
 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);
 -
--    for (i = 0; i < BUCKETS_COUNT; i++) {
+     if (!progress) {
--        throttle_unfix_bucket(&cfg->buckets[i]);
+         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;
              }
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 07/15] throttle: Make burst_length 64bit and add range checks
+[Qemu-devel] [PULL v2 14/24] block: explicitly acquire aiocontext in bottom halves that need it
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-LeakyBucket.burst_length is defined as an unsigned integer but the
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-code never checks for overflows and it only makes sure that the value
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-is not 0.
+Reviewed-by: Fam Zheng <famz@redhat.com>
+Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-In practice this means that the user can set something like
+Message-id: 20170213135235.12274-15-pbonzini@redhat.com
 throttling.iops-total-max-length=4294967300 despite being larger than
 UINT_MAX and the final value after casting to unsigned int will be 4.
 This patch changes the data type to uint64_t. This does not increase
 the storage size of LeakyBucket, and allows us to assign the value
 directly from qemu_opt_get_number() or BlockIOThrottle and then do the
 checks directly in throttle_is_valid().
 The value of burst_length does not have a specific upper limit,
 but since the bucket size is defined by max * burst_length we have
 to prevent overflows. Instead of going for UINT64_MAX or something
 similar this patch reuses THROTTLE_VALUE_MAX, which allows I/O bursts
 of 1 GiB/s for 10 days in a row.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-id: 1b2e3049803f71cafb2e1fa1be4fb47147a0d398.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/throttle.h | 2 +-
+ block/archipelago.c   |  3 +++
- util/throttle.c         | 5 +++++
+ block/blkreplay.c     |  2 +-
-files changed, 6 insertions(+), 1 deletion(-)
+ 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/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/block/archipelago.c b/block/archipelago.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/block/archipelago.c
-+++ b/include/qemu/throttle.h
++++ b/block/archipelago.c
-@@ -XXX,XX +XXX,XX @@ typedef struct LeakyBucket {
+@@ -XXX,XX +XXX,XX @@ static void qemu_archipelago_complete_aio(void *opaque)
-     uint64_t max;             /* leaky bucket max burst in units */
+ {
-     double  level;            /* bucket level in units */
+     AIORequestData *reqdata = (AIORequestData *) opaque;
-     double  burst_level;      /* bucket level in units (for computing bursts) */
+     ArchipelagoAIOCB *aio_cb = (ArchipelagoAIOCB *) reqdata->aio_cb;
--    unsigned burst_length;    /* max length of the burst period, in seconds */
++    AioContext *ctx = bdrv_get_aio_context(aio_cb->common.bs);
-+    uint64_t burst_length;    /* max length of the burst period, in seconds */
- } LeakyBucket;
++    aio_context_acquire(ctx);
+     aio_cb->common.cb(aio_cb->common.opaque, aio_cb->ret);
- /* The following structure is used to configure a ThrottleState
++    aio_context_release(ctx);
-diff --git a/util/throttle.c b/util/throttle.c
+     aio_cb->status = 0;
-index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+     qemu_aio_unref(aio_cb);
-+++ b/util/throttle.c
+diff --git a/block/blkreplay.c b/block/blkreplay.c
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
+index XXXXXXX..XXXXXXX 100755
-             return false;
+--- 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);
-+        if (bkt->max && bkt->burst_length > THROTTLE_VALUE_MAX / bkt->max) {
+     }
-+            error_setg(errp, "burst length too high for this burst rate");
++    aio_context_release(blk_get_aio_context(s->conf.blk));
-+            return false;
+ }
-+        }
-+
+ void scsi_req_retry(SCSIRequest *req)
-         if (bkt->max && !bkt->avg) {
+diff --git a/util/async.c b/util/async.c
-             error_setg(errp, "bps_max/iops_max require corresponding"
+index XXXXXXX..XXXXXXX 100644
-                        " bps/iops values");
+--- 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)
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 03/15] throttle: Update the throttle_fix_bucket() documentation
+[Qemu-devel] [PULL v2 15/24] block: explicitly acquire aiocontext in aio callbacks that need it
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-The way the throttling algorithm works is that requests start being
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-throttled once the bucket level exceeds the burst limit. When we get
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-there the bucket leaks at the level set by the user (bkt->avg), and
+Reviewed-by: Fam Zheng <famz@redhat.com>
-that leak rate is what prevents guest I/O from exceeding the desired
+Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-limit.
+Message-id: 20170213135235.12274-16-pbonzini@redhat.com
 If we don't allow bursts (i.e. bkt->max == 0) then we can start
 throttling requests immediately. The problem with keeping the
 threshold at 0 is that it only allows one request at a time, and as
 soon as there's a bit of I/O from the guest every other request will
 be throttled and performance will suffer considerably. That can even
 make the guest unable to reach the throttle limit if that limit is
 high enough, and that happens regardless of the block scheduler used
 by the guest.
 Increasing that threshold gives flexibility to the guest, allowing it
 to perform short bursts of I/O before being throttled. Increasing the
 threshold too much does not make a difference in the long run (because
 it's the leak rate what defines the actual throughput) but it does
 allow the guest to perform longer initial bursts and exceed the
 throttle limit for a short while.
 A burst value of bkt->avg / 10 allows the guest to perform 100ms'
 worth of I/O at the target rate without being throttled.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-id: 31aae6645f0d1fbf3860fb2b528b757236f0c0a7.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- util/throttle.c | 11 +++--------
+ block/archipelago.c    |  3 ---
-file changed, 3 insertions(+), 8 deletions(-)
+ 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 +++-
 files changed, 72 insertions(+), 50 deletions(-)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/block/archipelago.c b/block/archipelago.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/block/archipelago.c
-+++ b/util/throttle.c
++++ b/block/archipelago.c
-@@ -XXX,XX +XXX,XX @@ static void throttle_fix_bucket(LeakyBucket *bkt)
+@@ -XXX,XX +XXX,XX @@ static void qemu_archipelago_complete_aio(void *opaque)
-     /* zero bucket level */
+ {
-     bkt->level = bkt->burst_level = 0;
+     AIORequestData *reqdata = (AIORequestData *) opaque;
+     ArchipelagoAIOCB *aio_cb = (ArchipelagoAIOCB *) reqdata->aio_cb;
--    /* The following is done to cope with the Linux CFQ block scheduler
+-    AioContext *ctx = bdrv_get_aio_context(aio_cb->common.bs);
--     * which regroup reads and writes by block of 100ms in the guest.
--     * When they are two process one making reads and one making writes cfq
+-    aio_context_acquire(ctx);
--     * make a pattern looking like the following:
+     aio_cb->common.cb(aio_cb->common.opaque, aio_cb->ret);
--     * WWWWWWWWWWWRRRRRRRRRRRRRRWWWWWWWWWWWWWwRRRRRRRRRRRRRRRRR
+-    aio_context_release(ctx);
--     * Having a max burst value of 100ms of the average will help smooth the
+     aio_cb->status = 0;
--     * throttling
--     */
+     qemu_aio_unref(aio_cb);
-+    /* If bkt->max is 0 we still want to allow short bursts of I/O
+diff --git a/block/block-backend.c b/block/block-backend.c
-+     * from the guest, otherwise every other request will be throttled
+index XXXXXXX..XXXXXXX 100644
-+     * and performance will suffer considerably. */
+--- a/block/block-backend.c
-     min = bkt->avg / 10;
++++ b/block/block-backend.c
-     if (bkt->avg && !bkt->max) {
+@@ -XXX,XX +XXX,XX @@ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
-         bkt->max = min;
+ 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,
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 10/15] misc: Remove unused Error variables
+[Qemu-devel] [PULL v2 16/24] aio-posix: partially inline aio_dispatch into aio_poll
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-There's a few cases which we're passing an Error pointer to a function
+This patch prepares for the removal of unnecessary lockcnt inc/dec pairs.
-only to discard it immediately afterwards without checking it. In
+Extract the dispatching loop for file descriptor handlers into a new
-these cases we can simply remove the variable and pass NULL instead.
+function aio_dispatch_handlers, and then inline aio_dispatch into
 aio_poll.
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+aio_dispatch can now become void.
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20170829120836.16091-1-berto@igalia.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>
 ---
- block/qcow.c  | 12 +++---------
+ include/block/aio.h |  6 +-----
- block/qcow2.c |  8 ++------
+ util/aio-posix.c    | 44 ++++++++++++++------------------------------
- dump.c        |  4 +---
+ util/aio-win32.c    | 13 ++++---------
-files changed, 6 insertions(+), 18 deletions(-)
+ util/async.c        |  2 +-
 files changed, 20 insertions(+), 45 deletions(-)
-diff --git a/block/qcow.c b/block/qcow.c
+diff --git a/include/block/aio.h b/include/block/aio.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow.c
+--- a/include/block/aio.h
-+++ b/block/qcow.c
++++ b/include/block/aio.h
-@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ bool aio_pending(AioContext *ctx);
-                     start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
+ /* Dispatch any pending callbacks from the GSource attached to the AioContext.
-                     for(i = 0; i < s->cluster_sectors; i++) {
+  *
-                         if (i < n_start || i >= n_end) {
+  * This is used internally in the implementation of the GSource.
--                            Error *err = NULL;
+- *
-                             memset(s->cluster_data, 0x00, 512);
+- * @dispatch_fds: true to process fds, false to skip them
-                             if (qcrypto_block_encrypt(s->crypto, start_sect + i,
+- *                (can be used as an optimization by callers that know there
-                                                       s->cluster_data,
+- *                are no fds ready)
-                                                       BDRV_SECTOR_SIZE,
+  */
--                                                      &err) < 0) {
+-bool aio_dispatch(AioContext *ctx, bool dispatch_fds);
--                                error_free(err);
++void aio_dispatch(AioContext *ctx);
-+                                                      NULL) < 0) {
-                                 errno = EIO;
+ /* Progress in completing AIO work to occur.  This can issue new pending
-                                 return -1;
+  * aio as a result of executing I/O completion or bh callbacks.
-                             }
+diff --git a/util/aio-posix.c b/util/aio-posix.c
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
+index XXXXXXX..XXXXXXX 100644
-     QEMUIOVector hd_qiov;
+--- a/util/aio-posix.c
-     uint8_t *buf;
++++ b/util/aio-posix.c
-     void *orig_buf;
+@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
--    Error *err = NULL;
+     AioHandler *node, *tmp;
+     bool progress = false;
-     if (qiov->niov > 1) {
-         buf = orig_buf = qemu_try_blockalign(bs, qiov->size);
+-    /*
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
+-     * We have to walk very carefully in case aio_set_fd_handler is
-             if (bs->encrypted) {
+-     * called while we're walking.
-                 assert(s->crypto);
+-     */
-                 if (qcrypto_block_decrypt(s->crypto, sector_num, buf,
+-    qemu_lockcnt_inc(&ctx->list_lock);
--                                          n * BDRV_SECTOR_SIZE, &err) < 0) {
+-
-+                                          n * BDRV_SECTOR_SIZE, NULL) < 0) {
+     QLIST_FOREACH_SAFE_RCU(node, &ctx->aio_handlers, node, tmp) {
-                     goto fail;
+         int revents;
-                 }
-             }
+@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
-@@ -XXX,XX +XXX,XX @@ done:
+         }
-     return ret;
+     }
- fail:
+-    qemu_lockcnt_dec(&ctx->list_lock);
--    error_free(err);
+     return progress;
      ret = -EIO;
      goto done;
  }
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
-             break;
+-/*
-         }
+- * Note that dispatch_fds == false has the side-effect of post-poning the
-         if (bs->encrypted) {
+- * freeing of deleted handlers.
--            Error *err = NULL;
+- */
-             assert(s->crypto);
+-bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
-             if (qcrypto_block_encrypt(s->crypto, sector_num, buf,
++void aio_dispatch(AioContext *ctx)
--                                      n * BDRV_SECTOR_SIZE, &err) < 0) {
+ {
--                error_free(err);
+-    bool progress;
-+                                      n * BDRV_SECTOR_SIZE, NULL) < 0) {
++    aio_bh_poll(ctx);
-                 ret = -EIO;
-                 break;
+-    /*
-             }
+-     * If there are callbacks left that have been queued, we need to call them.
-diff --git a/block/qcow2.c b/block/qcow2.c
+-     * 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/block/qcow2.c
+--- a/util/aio-win32.c
-+++ b/block/qcow2.c
++++ b/util/aio-win32.c
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
+@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
-                 assert(s->crypto);
+     return progress;
-                 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
+ }
-                 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
--                Error *err = NULL;
+-bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
-                 if (qcrypto_block_decrypt(s->crypto,
++void aio_dispatch(AioContext *ctx)
-                                           (s->crypt_physical_offset ?
+ {
-                                            cluster_offset + offset_in_cluster :
+-    bool progress;
-                                            offset) >> BDRV_SECTOR_BITS,
+-
-                                           cluster_data,
+-    progress = aio_bh_poll(ctx);
-                                           cur_bytes,
+-    if (dispatch_fds) {
--                                          &err) < 0) {
+-        progress |= aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
--                    error_free(err);
+-    }
-+                                          NULL) < 0) {
+-    progress |= timerlistgroup_run_timers(&ctx->tlg);
-                     ret = -EIO;
+-    return progress;
-                     goto fail;
++    aio_bh_poll(ctx);
-                 }
++    aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
++    timerlistgroup_run_timers(&ctx->tlg);
-         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
+ }
-         if (bs->encrypted) {
+ bool aio_poll(AioContext *ctx, bool blocking)
--            Error *err = NULL;
+diff --git a/util/async.c b/util/async.c
              assert(s->crypto);
              if (!cluster_data) {
                  cluster_data = qemu_try_blockalign(bs->file->bs,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                                         cluster_offset + offset_in_cluster :
                                         offset) >> BDRV_SECTOR_BITS,
                                        cluster_data,
 -                                      cur_bytes, &err) < 0) {
 -                error_free(err);
 +                                      cur_bytes, NULL) < 0) {
                  ret = -EIO;
                  goto fail;
              }
 diff --git a/dump.c b/dump.c
 index XXXXXXX..XXXXXXX 100644
---- a/dump.c
+--- a/util/async.c
-+++ b/dump.c
++++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ static void dump_process(DumpState *s, Error **errp)
+@@ -XXX,XX +XXX,XX @@ aio_ctx_dispatch(GSource     *source,
+     AioContext *ctx = (AioContext *) source;
- static void *dump_thread(void *data)
- {
+     assert(callback == NULL);
--    Error *err = NULL;
+-    aio_dispatch(ctx, true);
-     DumpState *s = (DumpState *)data;
++    aio_dispatch(ctx);
--    dump_process(s, &err);
+     return true;
 -    error_free(err);
 +    dump_process(s, NULL);
      return NULL;
  }
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 06/15] throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
+[Qemu-devel] [PULL v2 17/24] async: remove unnecessary inc/dec pairs
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Both the throttling limits set with the throttling.iops-* and
+Pull the increment/decrement pair out of aio_bh_poll and into the
-throttling.bps-* options and their QMP equivalents defined in the
+callers.
 BlockIOThrottle struct are integer values.
-Those limits are also reported in the BlockDeviceInfo struct and they
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-are integers there as well.
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
-Therefore there's no reason to store them internally as double and do
+Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-the conversion everytime we're setting or querying them, so this patch
+Message-id: 20170213135235.12274-18-pbonzini@redhat.com
 uses uint64_t for those types. Let's also use an unsigned type because
 we don't allow negative values anyway.
 LeakyBucket.level and LeakyBucket.burst_level do however remain double
 because their value changes depending on the fraction of time elapsed
 since the previous I/O operation.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-id: f29b840422767b5be2c41c2dfdbbbf6c5f8fedf8.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/throttle.h | 4 ++--
+ util/aio-posix.c |  8 +++-----
- tests/test-throttle.c   | 3 ++-
+ util/aio-win32.c |  8 ++++----
- util/throttle.c         | 7 +++----
+ util/async.c     | 12 ++++++------
-files changed, 7 insertions(+), 7 deletions(-)
+files changed, 13 insertions(+), 15 deletions(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/util/aio-posix.c
-+++ b/include/qemu/throttle.h
++++ b/util/aio-posix.c
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
-  */
+ void aio_dispatch(AioContext *ctx)
- typedef struct LeakyBucket {
+ {
--    double  avg;              /* average goal in units per second */
++    qemu_lockcnt_inc(&ctx->list_lock);
--    double  max;              /* leaky bucket max burst in units */
+     aio_bh_poll(ctx);
-+    uint64_t avg;             /* average goal in units per second */
+-
-+    uint64_t max;             /* leaky bucket max burst in units */
+-    qemu_lockcnt_inc(&ctx->list_lock);
-     double  level;            /* bucket level in units */
+     aio_dispatch_handlers(ctx);
-     double  burst_level;      /* bucket level in units (for computing bursts) */
+     qemu_lockcnt_dec(&ctx->list_lock);
-     unsigned burst_length;    /* max length of the burst period, in seconds */
-diff --git a/tests/test-throttle.c b/tests/test-throttle.c
+@@ -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/tests/test-throttle.c
+--- a/util/aio-win32.c
-+++ b/tests/test-throttle.c
++++ b/util/aio-win32.c
-@@ -XXX,XX +XXX,XX @@ static void test_enabled(void)
+@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
-     for (i = 0; i < BUCKETS_COUNT; i++) {
+     bool progress = false;
-         throttle_config_init(&cfg);
+     AioHandler *tmp;
-         set_cfg_value(false, i, 150);
-+        g_assert(throttle_is_valid(&cfg, NULL));
+-    qemu_lockcnt_inc(&ctx->list_lock);
-         g_assert(throttle_enabled(&cfg));
+-
      /*
       * 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)
          }
      }
-     for (i = 0; i < BUCKETS_COUNT; i++) {
+-    qemu_lockcnt_dec(&ctx->list_lock);
-         throttle_config_init(&cfg);
+     return progress;
-         set_cfg_value(false, i, -150);
+ }
--        g_assert(!throttle_enabled(&cfg));
-+        g_assert(!throttle_is_valid(&cfg, NULL));
+ 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
 diff --git a/util/throttle.c b/util/throttle.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/util/async.c
-+++ b/util/throttle.c
++++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
+@@ -XXX,XX +XXX,XX @@ void aio_bh_call(QEMUBH *bh)
-         /* If bkt->max is 0 we still want to allow short bursts of I/O
+     bh->cb(bh->opaque);
-          * from the guest, otherwise every other request will be throttled
+ }
-          * and performance will suffer considerably. */
--        bucket_size = bkt->avg / 10;
+-/* Multiple occurrences of aio_bh_poll cannot be called concurrently */
-+        bucket_size = (double) bkt->avg / 10;
++/* Multiple occurrences of aio_bh_poll cannot be called concurrently.
-         burst_bucket_size = 0;
++ * The count in ctx->list_lock is incremented before the call, and is
-     } else {
++ * not affected by the call.
-         /* If we have a burst limit then we have to wait until all I/O
++ */
-          * at burst rate has finished before throttling to bkt->avg */
+ int aio_bh_poll(AioContext *ctx)
-         bucket_size = bkt->max * bkt->burst_length;
+ {
--        burst_bucket_size = bkt->max / 10;
+     QEMUBH *bh, **bhp, *next;
-+        burst_bucket_size = (double) bkt->max / 10;
+     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 the main bucket is full then we have to wait */
+-    if (qemu_lockcnt_dec_and_lock(&ctx->list_lock)) {
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
++    if (qemu_lockcnt_dec_if_lock(&ctx->list_lock)) {
+         bhp = &ctx->first_bh;
-     for (i = 0; i < BUCKETS_COUNT; i++) {
+         while (*bhp) {
-         LeakyBucket *bkt = &cfg->buckets[i];
+             bh = *bhp;
--        if (bkt->avg < 0 || bkt->max < 0 ||
+@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
--            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
+                 bhp = &bh->next;
-+        if (bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
+             }
-             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
+         }
-                        THROTTLE_VALUE_MAX);
+-        qemu_lockcnt_unlock(&ctx->list_lock);
-             return false;
++        qemu_lockcnt_inc_and_unlock(&ctx->list_lock);
      }
      return ret;
  }
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 02/15] throttle: Fix wrong variable name in the header documentation
+[Qemu-devel] [PULL v2 18/24] block: document fields protected by AioContext lock
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-The level of the burst bucket is stored in bkt.burst_level, not
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-bkt.burst_length.
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
+Message-id: 20170213135235.12274-19-pbonzini@redhat.com
 Message-id: 49aab2711d02f285567f3b3b13a113847af33812.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/throttle.h | 2 +-
+ include/block/block_int.h      | 64 +++++++++++++++++++++++++-----------------
-file changed, 1 insertion(+), 1 deletion(-)
+ include/sysemu/block-backend.h | 14 ++++++---
 files changed, 49 insertions(+), 29 deletions(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/include/block/block_int.h
-+++ b/include/qemu/throttle.h
++++ b/include/block/block_int.h
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ struct BdrvChild {
-  * - The bkt.avg rate does not apply until the bucket is full,
+  * copied as well.
-  *   allowing the user to do bursts until then. The I/O limit during
+  */
-  *   bursts is bkt.max. To enforce this limit we keep an additional
+ struct BlockDriverState {
-- *   bucket in bkt.burst_length that leaks at a rate of bkt.max units
+-    int64_t total_sectors; /* if we are reading a disk image, give its
-+ *   bucket in bkt.burst_level that leaks at a rate of bkt.max units
+-                              size in sectors */
-  *   per second.
++    /* Protected by big QEMU lock or read-only after opening.  No special
-  *
++     * locking needed during I/O...
-  * - Because of all of the above, the user can perform I/O at a
++     */
      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];
 --
-.13.5
+.9.3

-New patch
+[Qemu-devel] [PULL v2 19/24] coroutine-lock: make CoMutex thread-safe
+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 +
 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"
 --
 .9.3

-[Qemu-devel] [PULL for-2.10 04/15] throttle: Make throttle_is_valid() a bit less verbose
+[Qemu-devel] [PULL v2 20/24] coroutine-lock: add limited spinning to CoMutex
-From: Alberto Garcia <berto@igalia.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Use a pointer to the bucket instead of repeating cfg->buckets[i] all
+Running a very small critical section on pthread_mutex_t and CoMutex
-the time. This makes the code more concise and will help us expand the
+shows that pthread_mutex_t is much faster because it doesn't actually
-checks later and save a few line breaks.
+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.
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+This only works with one waiters; because CoMutex is fair, it will
-Message-id: 763ffc40a26b17d54cf93f5a999e4656049fcf0c.1503580370.git.berto@igalia.com
+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>
 ---
- util/throttle.c | 15 +++++++--------
+ include/qemu/coroutine.h   |  5 +++++
-file changed, 7 insertions(+), 8 deletions(-)
+ util/qemu-coroutine-lock.c | 51 ++++++++++++++++++++++++++++++++++++++++------
  util/qemu-coroutine.c      |  2 +-
 files changed, 51 insertions(+), 7 deletions(-)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/include/qemu/coroutine.h
-+++ b/util/throttle.c
++++ b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
+@@ -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);
      }
-     for (i = 0; i < BUCKETS_COUNT; i++) {
+     qemu_coroutine_yield();
--        if (cfg->buckets[i].avg < 0 ||
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
--            cfg->buckets[i].max < 0 ||
--            cfg->buckets[i].avg > THROTTLE_VALUE_MAX ||
+ void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
--            cfg->buckets[i].max > THROTTLE_VALUE_MAX) {
+ {
-+        LeakyBucket *bkt = &cfg->buckets[i];
++    AioContext *ctx = qemu_get_current_aio_context();
-+        if (bkt->avg < 0 || bkt->max < 0 ||
+     Coroutine *self = qemu_coroutine_self();
-+            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
++    int waiters, i;
-             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
-                        THROTTLE_VALUE_MAX);
+-    if (atomic_fetch_inc(&mutex->locked) == 0) {
-             return false;
++    /* 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;
          }
--        if (!cfg->buckets[i].burst_length) {
+diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
-+        if (!bkt->burst_length) {
+index XXXXXXX..XXXXXXX 100644
-             error_setg(errp, "the burst length cannot be 0");
+--- a/util/qemu-coroutine.c
-             return false;
++++ b/util/qemu-coroutine.c
-         }
+@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_enter(Coroutine *co)
+     co->ctx = qemu_get_current_aio_context();
--        if (cfg->buckets[i].burst_length > 1 && !cfg->buckets[i].max) {
-+        if (bkt->burst_length > 1 && !bkt->max) {
+     /* Store co->ctx before anything that stores co.  Matches
-             error_setg(errp, "burst length set without burst rate");
+-     * barrier in aio_co_wake.
-             return false;
++     * barrier in aio_co_wake and qemu_co_mutex_wake.
-         }
+      */
+     smp_wmb();
--        if (cfg->buckets[i].max && !cfg->buckets[i].avg) {
 +        if (bkt->max && !bkt->avg) {
              error_setg(errp, "bps_max/iops_max require corresponding"
                         " bps/iops values");
              return false;
          }
 -        if (cfg->buckets[i].max && cfg->buckets[i].max < cfg->buckets[i].avg) {
 +        if (bkt->max && bkt->max < bkt->avg) {
              error_setg(errp, "bps_max/iops_max cannot be lower than bps/iops");
              return false;
          }
 --
-.13.5
+.9.3

-New patch
+[Qemu-devel] [PULL v2 21/24] test-aio-multithread: add performance comparison with thread-based mutexes
+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 +++++++++++++++++++++++++++++++++++++++++++
 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();
  }
 --
 .9.3

-[Qemu-devel] [PULL for-2.10 14/15] qemu-doc: Add UUID support in initiator name
+[Qemu-devel] [PULL v2 22/24] coroutine-lock: place CoMutex before CoQueue in header
-From: Fred Rolland <rollandf@gmail.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Update doc with the usage of UUID for initiator name.
+This will avoid forward references in the next patch.  It is also
 more logical because CoQueue is not anymore the basic primitive.
-Related-To: https://bugzilla.redhat.com/1006468
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Signed-off-by: Fred Rolland <frolland@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
-Message-id: 20170823084830.30500-1-frolland@redhat.com
+Message-id: 20170213181244.16297-5-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qemu-doc.texi | 5 +++--
+ include/qemu/coroutine.h | 89 ++++++++++++++++++++++++------------------------
-file changed, 3 insertions(+), 2 deletions(-)
+file changed, 44 insertions(+), 45 deletions(-)
-diff --git a/qemu-doc.texi b/qemu-doc.texi
+diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-doc.texi
+--- a/include/qemu/coroutine.h
-+++ b/qemu-doc.texi
++++ b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@ in a configuration file provided via '-readconfig' or directly on the
+@@ -XXX,XX +XXX,XX @@ bool qemu_in_coroutine(void);
- command line.
+  */
+ bool qemu_coroutine_entered(Coroutine *co);
  If the initiator-name is not specified qemu will use a default name
 -of 'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
 +of 'iqn.2008-11.org.linux-kvm[:<uuid>'] where <uuid> is the UUID of the
 +virtual machine. If the UUID is not specified qemu will use
 +'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
  virtual machine.
 -
- @example
+-/**
- Setting a specific initiator name to use when logging in to the target
+- * CoQueues are a mechanism to queue coroutines in order to continue executing
- -iscsi initiator-name=iqn.qemu.test:my-initiator
+- * 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;
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 15/15] qcow2: allocate cluster_cache/cluster_data on demand
+[Qemu-devel] [PULL v2 23/24] coroutine-lock: add mutex argument to CoQueue APIs
-Most qcow2 files are uncompressed so it is wasteful to allocate (32 + 1)
+From: Paolo Bonzini <pbonzini@redhat.com>
-* cluster_size + 512 bytes upfront.  Allocate s->cluster_cache and
-s->cluster_data when the first read operation is performance on a
+All that CoQueue needs in order to become thread-safe is help
-compressed cluster.
+from an external mutex.  Add this to the API.
-The buffers are freed in .bdrv_close().  .bdrv_open() no longer has any
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-code paths that can allocate these buffers, so remove the free functions
+Reviewed-by: Fam Zheng <famz@redhat.com>
-in the error code path.
+Message-id: 20170213181244.16297-6-pbonzini@redhat.com
 This patch can result in significant memory savings when many qcow2
 disks are attached or backing file chains are long:
 Before 12.81% (1,023,193,088B)
 After   5.36% (393,893,888B)
 Reported-by: Alexey Kardashevskiy <aik@ozlabs.ru>
 Tested-by: Alexey Kardashevskiy <aik@ozlabs.ru>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20170821135530.32344-1-stefanha@redhat.com
 Cc: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/qcow2-cluster.c | 17 +++++++++++++++++
+ include/qemu/coroutine.h   |  8 +++++---
- block/qcow2.c         | 12 ------------
+ block/backup.c             |  2 +-
-files changed, 17 insertions(+), 12 deletions(-)
+ 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 +++++++++++++++++++++---
 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 @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
+@@ -XXX,XX +XXX,XX @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
-         nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
+             if (bytes == 0) {
-         sector_offset = coffset & 511;
+                 /* Wait for the dependency to complete. We need to recheck
-         csize = nb_csectors * 512 - sector_offset;
+                  * 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);
 +
-+        /* Allocate buffers on first decompress operation, most images are
++    if (mutex) {
-+         * uncompressed and the memory overhead can be avoided.  The buffers
++        qemu_co_mutex_unlock(mutex);
-+         * are freed in .bdrv_close().
++    }
 +         */
 +        if (!s->cluster_data) {
 +            /* one more sector for decompressed data alignment */
 +            s->cluster_data = qemu_try_blockalign(bs->file->bs,
 +                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size + 512);
 +            if (!s->cluster_data) {
 +                return -ENOMEM;
 +            }
 +        }
 +        if (!s->cluster_cache) {
 +            s->cluster_cache = g_malloc(s->cluster_size);
 +        }
 +
-         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
++    /* There is no race condition here.  Other threads will call
-         ret = bdrv_read(bs->file, coffset >> 9, s->cluster_data,
++     * aio_co_schedule on our AioContext, which can reenter this
-                         nb_csectors);
++     * coroutine but only after this yield and after the main loop
-diff --git a/block/qcow2.c b/block/qcow2.c
++     * has gone through the next iteration.
-index XXXXXXX..XXXXXXX 100644
++     */
---- a/block/qcow2.c
+     qemu_coroutine_yield();
-+++ b/block/qcow2.c
+     assert(qemu_in_coroutine());
-@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
++
-         goto fail;
++    /* 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.
--    s->cluster_cache = g_malloc(s->cluster_size);
++     */
--    /* one more sector for decompressed data alignment */
++    if (mutex) {
--    s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
++        qemu_co_mutex_lock(mutex);
--                                                    * s->cluster_size + 512);
++    }
--    if (s->cluster_data == NULL) {
+ }
--        error_setg(errp, "Could not allocate temporary cluster buffer");
--        ret = -ENOMEM;
+ /**
--        goto fail;
+@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_rdlock(CoRwlock *lock)
--    }
+     Coroutine *self = qemu_coroutine_self();
--
-     s->cluster_cache_offset = -1;
+     while (lock->writer) {
-     s->flags = flags;
+-        qemu_co_queue_wait(&lock->queue);
++        qemu_co_queue_wait(&lock->queue, NULL);
-@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+     }
-     if (s->refcount_block_cache) {
+     lock->reader++;
-         qcow2_cache_destroy(bs, s->refcount_block_cache);
+     self->locks_held++;
-     }
+@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_wrlock(CoRwlock *lock)
--    g_free(s->cluster_cache);
+     Coroutine *self = qemu_coroutine_self();
--    qemu_vfree(s->cluster_data);
-     qcrypto_block_free(s->crypto);
+     while (lock->writer || lock->reader) {
-     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
+-        qemu_co_queue_wait(&lock->queue);
-     return ret;
++        qemu_co_queue_wait(&lock->queue, NULL);
      }
      lock->writer = true;
      self->locks_held++;
 --
-.13.5
+.9.3

-[Qemu-devel] [PULL for-2.10 01/15] nvme: Fix get/set number of queues feature, again
+[Qemu-devel] [PULL v2 24/24] coroutine-lock: make CoRwlock thread-safe and fair
-From: Dan Aloni <dan@kernelim.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-The number of queues that should be return by the admin command should:
+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.
-) Only mention the number of non-admin queues.
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-) It is zero-based, meaning that '0 == one non-admin queue',
+Reviewed-by: Fam Zheng <famz@redhat.com>
-     '1 == two non-admin queues', and so forth.
+Message-id: 20170213181244.16297-7-pbonzini@redhat.com
 Because our `num_queues` means the number of queues _plus_ the admin
 queue, then the right calculation for the number returned from the admin
 command is `num_queues - 2`, combining the two requirements mentioned.
 The issue was discovered by reducing num_queues from 64 to 8 and running
 a Linux VM with an SMP parameter larger than that (e.g. 22). It tries to
 utilize all queues, and therefore fails with an invalid queue number
 when trying to queue I/Os on the last queue.
 Signed-off-by: Dan Aloni <dan@kernelim.com>
 CC: Alex Friedman <alex@e8storage.com>
 CC: Keith Busch <keith.busch@intel.com>
 CC: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Keith Busch <keith.busch@intel.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/block/nvme.c | 4 ++--
+ include/qemu/coroutine.h   |  3 ++-
-file changed, 2 insertions(+), 2 deletions(-)
+ util/qemu-coroutine-lock.c | 35 ++++++++++++++++++++++++-----------
 files changed, 26 insertions(+), 12 deletions(-)
-diff --git a/hw/block/nvme.c b/hw/block/nvme.c
+diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/nvme.c
+--- a/include/qemu/coroutine.h
-+++ b/hw/block/nvme.c
++++ b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
+@@ -XXX,XX +XXX,XX @@ bool qemu_co_queue_empty(CoQueue *queue);
-         result = blk_enable_write_cache(n->conf.blk);
-         break;
-     case NVME_NUMBER_OF_QUEUES:
+ typedef struct CoRwlock {
--        result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
+-    bool writer;
-+        result = cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
++    int pending_writer;
-         break;
+     int reader;
-     default:
++    CoMutex mutex;
-         return NVME_INVALID_FIELD | NVME_DNR;
+     CoQueue queue;
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
+ } CoRwlock;
-         break;
-     case NVME_NUMBER_OF_QUEUES:
+diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
-         req->cqe.result =
+index XXXXXXX..XXXXXXX 100644
--            cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
+--- a/util/qemu-coroutine-lock.c
-+            cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
++++ b/util/qemu-coroutine-lock.c
-         break;
+@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_init(CoRwlock *lock)
-     default:
+ {
-         return NVME_INVALID_FIELD | NVME_DNR;
+     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.
 +     */
  }
 --
-.13.5
+.9.3

The following changes since commit 248b23735645f7cbb503d9be6f5bf825f2a603ab:

Update version for v2.10.0-rc4 release (2017-08-24 17:34:26 +0100)

are available in the git repository at:

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

for you to fetch changes up to 3e4c705212abfe8c9882a00beb2d1466a8a53cec:

qcow2: allocate cluster_cache/cluster_data on demand (2017-08-30 18:02:10 +0100)

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

Alberto Garcia (8):
  throttle: Fix wrong variable name in the header documentation
  throttle: Update the throttle_fix_bucket() documentation
  throttle: Make throttle_is_valid() a bit less verbose
  throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
  throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
  throttle: Make burst_length 64bit and add range checks
  throttle: Test the valid range of config values
  misc: Remove unused Error variables

Dan Aloni (1):
  nvme: Fix get/set number of queues feature, again

Eduardo Habkost (1):
  oslib-posix: Print errors before aborting on qemu_alloc_stack()

Fred Rolland (1):
  qemu-doc: Add UUID support in initiator name

Stefan Hajnoczi (4):
  scripts: add argparse module for Python 2.6 compatibility
  docker.py: Python 2.6 argparse compatibility
  tests: migration/guestperf Python 2.6 argparse compatibility
  qcow2: allocate cluster_cache/cluster_data on demand

-- 
2.13.5

From: Dan Aloni <dan@kernelim.com>

The number of queues that should be return by the admin command should:

1) Only mention the number of non-admin queues.
  2) It is zero-based, meaning that '0 == one non-admin queue',
     '1 == two non-admin queues', and so forth.

Because our `num_queues` means the number of queues _plus_ the admin
queue, then the right calculation for the number returned from the admin
command is `num_queues - 2`, combining the two requirements mentioned.

The issue was discovered by reducing num_queues from 64 to 8 and running
a Linux VM with an SMP parameter larger than that (e.g. 22). It tries to
utilize all queues, and therefore fails with an invalid queue number
when trying to queue I/Os on the last queue.

Signed-off-by: Dan Aloni <dan@kernelim.com>
CC: Alex Friedman <alex@e8storage.com>
CC: Keith Busch <keith.busch@intel.com>
CC: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Keith Busch <keith.busch@intel.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/nvme.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hw/block/nvme.c b/hw/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.c
+++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
         result = blk_enable_write_cache(n->conf.blk);
         break;
     case NVME_NUMBER_OF_QUEUES:
-        result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
+        result = cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
         break;
     default:
         return NVME_INVALID_FIELD | NVME_DNR;
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
         break;
     case NVME_NUMBER_OF_QUEUES:
         req->cqe.result =
-            cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
+            cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
         break;
     default:
         return NVME_INVALID_FIELD | NVME_DNR;
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

The level of the burst bucket is stored in bkt.burst_level, not
bkt.burst_length.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
Message-id: 49aab2711d02f285567f3b3b13a113847af33812.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/throttle.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
  * - The bkt.avg rate does not apply until the bucket is full,
  *   allowing the user to do bursts until then. The I/O limit during
  *   bursts is bkt.max. To enforce this limit we keep an additional
- *   bucket in bkt.burst_length that leaks at a rate of bkt.max units
+ *   bucket in bkt.burst_level that leaks at a rate of bkt.max units
  *   per second.
  *
  * - Because of all of the above, the user can perform I/O at a
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

The way the throttling algorithm works is that requests start being
throttled once the bucket level exceeds the burst limit. When we get
there the bucket leaks at the level set by the user (bkt->avg), and
that leak rate is what prevents guest I/O from exceeding the desired
limit.

If we don't allow bursts (i.e. bkt->max == 0) then we can start
throttling requests immediately. The problem with keeping the
threshold at 0 is that it only allows one request at a time, and as
soon as there's a bit of I/O from the guest every other request will
be throttled and performance will suffer considerably. That can even
make the guest unable to reach the throttle limit if that limit is
high enough, and that happens regardless of the block scheduler used
by the guest.

Increasing that threshold gives flexibility to the guest, allowing it
to perform short bursts of I/O before being throttled. Increasing the
threshold too much does not make a difference in the long run (because
it's the leak rate what defines the actual throughput) but it does
allow the guest to perform longer initial bursts and exceed the
throttle limit for a short while.

A burst value of bkt->avg / 10 allows the guest to perform 100ms'
worth of I/O at the target rate without being throttled.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 31aae6645f0d1fbf3860fb2b528b757236f0c0a7.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/throttle.c | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ static void throttle_fix_bucket(LeakyBucket *bkt)
     /* zero bucket level */
     bkt->level = bkt->burst_level = 0;
 
-    /* The following is done to cope with the Linux CFQ block scheduler
-     * which regroup reads and writes by block of 100ms in the guest.
-     * When they are two process one making reads and one making writes cfq
-     * make a pattern looking like the following:
-     * WWWWWWWWWWWRRRRRRRRRRRRRRWWWWWWWWWWWWWwRRRRRRRRRRRRRRRRR
-     * Having a max burst value of 100ms of the average will help smooth the
-     * throttling
-     */
+    /* If bkt->max is 0 we still want to allow short bursts of I/O
+     * from the guest, otherwise every other request will be throttled
+     * and performance will suffer considerably. */
     min = bkt->avg / 10;
     if (bkt->avg && !bkt->max) {
         bkt->max = min;
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

Use a pointer to the bucket instead of repeating cfg->buckets[i] all
the time. This makes the code more concise and will help us expand the
checks later and save a few line breaks.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 763ffc40a26b17d54cf93f5a999e4656049fcf0c.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/throttle.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
     }
 
     for (i = 0; i < BUCKETS_COUNT; i++) {
-        if (cfg->buckets[i].avg < 0 ||
-            cfg->buckets[i].max < 0 ||
-            cfg->buckets[i].avg > THROTTLE_VALUE_MAX ||
-            cfg->buckets[i].max > THROTTLE_VALUE_MAX) {
+        LeakyBucket *bkt = &cfg->buckets[i];
+        if (bkt->avg < 0 || bkt->max < 0 ||
+            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
                        THROTTLE_VALUE_MAX);
             return false;
         }
 
-        if (!cfg->buckets[i].burst_length) {
+        if (!bkt->burst_length) {
             error_setg(errp, "the burst length cannot be 0");
             return false;
         }
 
-        if (cfg->buckets[i].burst_length > 1 && !cfg->buckets[i].max) {
+        if (bkt->burst_length > 1 && !bkt->max) {
             error_setg(errp, "burst length set without burst rate");
             return false;
         }
 
-        if (cfg->buckets[i].max && !cfg->buckets[i].avg) {
+        if (bkt->max && !bkt->avg) {
             error_setg(errp, "bps_max/iops_max require corresponding"
                        " bps/iops values");
             return false;
         }
 
-        if (cfg->buckets[i].max && cfg->buckets[i].max < cfg->buckets[i].avg) {
+        if (bkt->max && bkt->max < bkt->avg) {
             error_setg(errp, "bps_max/iops_max cannot be lower than bps/iops");
             return false;
         }
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

The throttling code can change internally the value of bkt->max if it
hasn't been set by the user. The problem with this is that if we want
to retrieve the original value we have to undo this change first. This
is ugly and unnecessary: this patch removes the throttle_fix_bucket()
and throttle_unfix_bucket() functions completely and moves the logic
to throttle_compute_wait().

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
Message-id: 5b0b9e1ac6eb208d709eddc7b09e7669a523bff3.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/throttle.c | 62 +++++++++++++++++++++------------------------------------
 1 file changed, 23 insertions(+), 39 deletions(-)

diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ static int64_t throttle_do_compute_wait(double limit, double extra)
 int64_t throttle_compute_wait(LeakyBucket *bkt)
 {
     double extra; /* the number of extra units blocking the io */
+    double bucket_size;   /* I/O before throttling to bkt->avg */
+    double burst_bucket_size; /* Before throttling to bkt->max */
 
     if (!bkt->avg) {
         return 0;
     }
 
-    /* If the bucket is full then we have to wait */
-    extra = bkt->level - bkt->max * bkt->burst_length;
+    if (!bkt->max) {
+        /* If bkt->max is 0 we still want to allow short bursts of I/O
+         * from the guest, otherwise every other request will be throttled
+         * and performance will suffer considerably. */
+        bucket_size = bkt->avg / 10;
+        burst_bucket_size = 0;
+    } else {
+        /* If we have a burst limit then we have to wait until all I/O
+         * at burst rate has finished before throttling to bkt->avg */
+        bucket_size = bkt->max * bkt->burst_length;
+        burst_bucket_size = bkt->max / 10;
+    }
+
+    /* If the main bucket is full then we have to wait */
+    extra = bkt->level - bucket_size;
     if (extra > 0) {
         return throttle_do_compute_wait(bkt->avg, extra);
     }
 
-    /* If the bucket is not full yet we have to make sure that we
-     * fulfill the goal of bkt->max units per second. */
+    /* If the main bucket is not full yet we still have to check the
+     * burst bucket in order to enforce the burst limit */
     if (bkt->burst_length > 1) {
-        /* We use 1/10 of the max value to smooth the throttling.
-         * See throttle_fix_bucket() for more details. */
-        extra = bkt->burst_level - bkt->max / 10;
+        extra = bkt->burst_level - burst_bucket_size;
         if (extra > 0) {
             return throttle_do_compute_wait(bkt->max, extra);
         }
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
     return true;
 }
 
-/* fix bucket parameters */
-static void throttle_fix_bucket(LeakyBucket *bkt)
-{
-    double min;
-
-    /* zero bucket level */
-    bkt->level = bkt->burst_level = 0;
-
-    /* If bkt->max is 0 we still want to allow short bursts of I/O
-     * from the guest, otherwise every other request will be throttled
-     * and performance will suffer considerably. */
-    min = bkt->avg / 10;
-    if (bkt->avg && !bkt->max) {
-        bkt->max = min;
-    }
-}
-
-/* undo internal bucket parameter changes (see throttle_fix_bucket()) */
-static void throttle_unfix_bucket(LeakyBucket *bkt)
-{
-    if (bkt->max < bkt->avg) {
-        bkt->max = 0;
-    }
-}
-
 /* Used to configure the throttle
  *
  * @ts: the throttle state we are working on
@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
 
     ts->cfg = *cfg;
 
+    /* Zero bucket level */
     for (i = 0; i < BUCKETS_COUNT; i++) {
-        throttle_fix_bucket(&ts->cfg.buckets[i]);
+        ts->cfg.buckets[i].level = 0;
+        ts->cfg.buckets[i].burst_level = 0;
     }
 
     ts->previous_leak = qemu_clock_get_ns(clock_type);
@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
  */
 void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
 {
-    int i;
-
     *cfg = ts->cfg;
-
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        throttle_unfix_bucket(&cfg->buckets[i]);
-    }
 }
 
 
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

Both the throttling limits set with the throttling.iops-* and
throttling.bps-* options and their QMP equivalents defined in the
BlockIOThrottle struct are integer values.

Those limits are also reported in the BlockDeviceInfo struct and they
are integers there as well.

Therefore there's no reason to store them internally as double and do
the conversion everytime we're setting or querying them, so this patch
uses uint64_t for those types. Let's also use an unsigned type because
we don't allow negative values anyway.

LeakyBucket.level and LeakyBucket.burst_level do however remain double
because their value changes depending on the fraction of time elapsed
since the previous I/O operation.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: f29b840422767b5be2c41c2dfdbbbf6c5f8fedf8.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/throttle.h | 4 ++--
 tests/test-throttle.c   | 3 ++-
 util/throttle.c         | 7 +++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
  */
 
 typedef struct LeakyBucket {
-    double  avg;              /* average goal in units per second */
-    double  max;              /* leaky bucket max burst in units */
+    uint64_t avg;             /* average goal in units per second */
+    uint64_t max;             /* leaky bucket max burst in units */
     double  level;            /* bucket level in units */
     double  burst_level;      /* bucket level in units (for computing bursts) */
     unsigned burst_length;    /* max length of the burst period, in seconds */
diff --git a/tests/test-throttle.c b/tests/test-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-throttle.c
+++ b/tests/test-throttle.c
@@ -XXX,XX +XXX,XX @@ static void test_enabled(void)
     for (i = 0; i < BUCKETS_COUNT; i++) {
         throttle_config_init(&cfg);
         set_cfg_value(false, i, 150);
+        g_assert(throttle_is_valid(&cfg, NULL));
         g_assert(throttle_enabled(&cfg));
     }
 
     for (i = 0; i < BUCKETS_COUNT; i++) {
         throttle_config_init(&cfg);
         set_cfg_value(false, i, -150);
-        g_assert(!throttle_enabled(&cfg));
+        g_assert(!throttle_is_valid(&cfg, NULL));
     }
 }
 
diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
         /* If bkt->max is 0 we still want to allow short bursts of I/O
          * from the guest, otherwise every other request will be throttled
          * and performance will suffer considerably. */
-        bucket_size = bkt->avg / 10;
+        bucket_size = (double) bkt->avg / 10;
         burst_bucket_size = 0;
     } else {
         /* If we have a burst limit then we have to wait until all I/O
          * at burst rate has finished before throttling to bkt->avg */
         bucket_size = bkt->max * bkt->burst_length;
-        burst_bucket_size = bkt->max / 10;
+        burst_bucket_size = (double) bkt->max / 10;
     }
 
     /* If the main bucket is full then we have to wait */
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
 
     for (i = 0; i < BUCKETS_COUNT; i++) {
         LeakyBucket *bkt = &cfg->buckets[i];
-        if (bkt->avg < 0 || bkt->max < 0 ||
-            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
+        if (bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
                        THROTTLE_VALUE_MAX);
             return false;
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

LeakyBucket.burst_length is defined as an unsigned integer but the
code never checks for overflows and it only makes sure that the value
is not 0.

In practice this means that the user can set something like
throttling.iops-total-max-length=4294967300 despite being larger than
UINT_MAX and the final value after casting to unsigned int will be 4.

This patch changes the data type to uint64_t. This does not increase
the storage size of LeakyBucket, and allows us to assign the value
directly from qemu_opt_get_number() or BlockIOThrottle and then do the
checks directly in throttle_is_valid().

The value of burst_length does not have a specific upper limit,
but since the bucket size is defined by max * burst_length we have
to prevent overflows. Instead of going for UINT64_MAX or something
similar this patch reuses THROTTLE_VALUE_MAX, which allows I/O bursts
of 1 GiB/s for 10 days in a row.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 1b2e3049803f71cafb2e1fa1be4fb47147a0d398.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/throttle.h | 2 +-
 util/throttle.c         | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -XXX,XX +XXX,XX @@ typedef struct LeakyBucket {
     uint64_t max;             /* leaky bucket max burst in units */
     double  level;            /* bucket level in units */
     double  burst_level;      /* bucket level in units (for computing bursts) */
-    unsigned burst_length;    /* max length of the burst period, in seconds */
+    uint64_t burst_length;    /* max length of the burst period, in seconds */
 } LeakyBucket;
 
 /* The following structure is used to configure a ThrottleState
diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
             return false;
         }
 
+        if (bkt->max && bkt->burst_length > THROTTLE_VALUE_MAX / bkt->max) {
+            error_setg(errp, "burst length too high for this burst rate");
+            return false;
+        }
+
         if (bkt->max && !bkt->avg) {
             error_setg(errp, "bps_max/iops_max require corresponding"
                        " bps/iops values");
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: a57dd6274e1b6dc9c28769fec4c7ea543be5c5e3.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/test-throttle.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/tests/test-throttle.c b/tests/test-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-throttle.c
+++ b/tests/test-throttle.c
@@ -XXX,XX +XXX,XX @@ static void test_is_valid(void)
     test_is_valid_for_value(1, true);
 }
 
+static void test_ranges(void)
+{
+    int i;
+
+    for (i = 0; i < BUCKETS_COUNT; i++) {
+        LeakyBucket *b = &cfg.buckets[i];
+        throttle_config_init(&cfg);
+
+        /* avg = 0 means throttling is disabled, but the config is valid */
+        b->avg = 0;
+        g_assert(throttle_is_valid(&cfg, NULL));
+        g_assert(!throttle_enabled(&cfg));
+
+        /* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
+        b->avg = 1;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = THROTTLE_VALUE_MAX;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = THROTTLE_VALUE_MAX;
+        b->max = THROTTLE_VALUE_MAX;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        /* Values over THROTTLE_VALUE_MAX are not allowed */
+        b->avg = THROTTLE_VALUE_MAX + 1;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        b->avg = THROTTLE_VALUE_MAX;
+        b->max = THROTTLE_VALUE_MAX + 1;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        /* burst_length must be between 1 and THROTTLE_VALUE_MAX */
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = 0;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = 1;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = THROTTLE_VALUE_MAX;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = THROTTLE_VALUE_MAX + 1;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        /* burst_length * max cannot exceed THROTTLE_VALUE_MAX */
+        b->avg = 1;
+        b->max = 2;
+        b->burst_length = THROTTLE_VALUE_MAX / 2;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 3;
+        b->burst_length = THROTTLE_VALUE_MAX / 2;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = THROTTLE_VALUE_MAX;
+        b->burst_length = 1;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = THROTTLE_VALUE_MAX;
+        b->burst_length = 2;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+    }
+}
+
 static void test_max_is_missing_limit(void)
 {
     int i;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/throttle/config/enabled",     test_enabled);
     g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
     g_test_add_func("/throttle/config/is_valid",    test_is_valid);
+    g_test_add_func("/throttle/config/ranges",      test_ranges);
     g_test_add_func("/throttle/config/max",         test_max_is_missing_limit);
     g_test_add_func("/throttle/config/iops_size",
                     test_iops_size_is_missing_limit);
-- 
2.13.5

From: Eduardo Habkost <ehabkost@redhat.com>

If QEMU is running on a system that's out of memory and mmap()
fails, QEMU aborts with no error message at all, making it hard
to debug the reason for the failure.

Add perror() calls that will print error information before
aborting.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Tested-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20170829212053.6003-1-ehabkost@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/oslib-posix.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/util/oslib-posix.c b/util/oslib-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/oslib-posix.c
+++ b/util/oslib-posix.c
@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
     ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (ptr == MAP_FAILED) {
+        perror("failed to allocate memory for stack");
         abort();
     }
 
@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
     guardpage = ptr;
 #endif
     if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
+        perror("failed to set up stack guard page");
         abort();
     }
 
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

There's a few cases which we're passing an Error pointer to a function
only to discard it immediately afterwards without checking it. In
these cases we can simply remove the variable and pass NULL instead.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20170829120836.16091-1-berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow.c  | 12 +++---------
 block/qcow2.c |  8 ++------
 dump.c        |  4 +---
 3 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
                     start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
                     for(i = 0; i < s->cluster_sectors; i++) {
                         if (i < n_start || i >= n_end) {
-                            Error *err = NULL;
                             memset(s->cluster_data, 0x00, 512);
                             if (qcrypto_block_encrypt(s->crypto, start_sect + i,
                                                       s->cluster_data,
                                                       BDRV_SECTOR_SIZE,
-                                                      &err) < 0) {
-                                error_free(err);
+                                                      NULL) < 0) {
                                 errno = EIO;
                                 return -1;
                             }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
     QEMUIOVector hd_qiov;
     uint8_t *buf;
     void *orig_buf;
-    Error *err = NULL;
 
     if (qiov->niov > 1) {
         buf = orig_buf = qemu_try_blockalign(bs, qiov->size);
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
             if (bs->encrypted) {
                 assert(s->crypto);
                 if (qcrypto_block_decrypt(s->crypto, sector_num, buf,
-                                          n * BDRV_SECTOR_SIZE, &err) < 0) {
+                                          n * BDRV_SECTOR_SIZE, NULL) < 0) {
                     goto fail;
                 }
             }
@@ -XXX,XX +XXX,XX @@ done:
     return ret;
 
 fail:
-    error_free(err);
     ret = -EIO;
     goto done;
 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
             break;
         }
         if (bs->encrypted) {
-            Error *err = NULL;
             assert(s->crypto);
             if (qcrypto_block_encrypt(s->crypto, sector_num, buf,
-                                      n * BDRV_SECTOR_SIZE, &err) < 0) {
-                error_free(err);
+                                      n * BDRV_SECTOR_SIZE, NULL) < 0) {
                 ret = -EIO;
                 break;
             }
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
                 assert(s->crypto);
                 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
                 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
-                Error *err = NULL;
                 if (qcrypto_block_decrypt(s->crypto,
                                           (s->crypt_physical_offset ?
                                            cluster_offset + offset_in_cluster :
                                            offset) >> BDRV_SECTOR_BITS,
                                           cluster_data,
                                           cur_bytes,
-                                          &err) < 0) {
-                    error_free(err);
+                                          NULL) < 0) {
                     ret = -EIO;
                     goto fail;
                 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
 
         if (bs->encrypted) {
-            Error *err = NULL;
             assert(s->crypto);
             if (!cluster_data) {
                 cluster_data = qemu_try_blockalign(bs->file->bs,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                                        cluster_offset + offset_in_cluster :
                                        offset) >> BDRV_SECTOR_BITS,
                                       cluster_data,
-                                      cur_bytes, &err) < 0) {
-                error_free(err);
+                                      cur_bytes, NULL) < 0) {
                 ret = -EIO;
                 goto fail;
             }
diff --git a/dump.c b/dump.c
index XXXXXXX..XXXXXXX 100644
--- a/dump.c
+++ b/dump.c
@@ -XXX,XX +XXX,XX @@ static void dump_process(DumpState *s, Error **errp)
 
 static void *dump_thread(void *data)
 {
-    Error *err = NULL;
     DumpState *s = (DumpState *)data;
-    dump_process(s, &err);
-    error_free(err);
+    dump_process(s, NULL);
     return NULL;
 }
 
-- 
2.13.5

The minimum Python version supported by QEMU is 2.6.  The argparse
standard library module was only added in Python 2.7.  Many scripts
would like to use argparse because it supports command-line
sub-commands.

This patch adds argparse.  See the top of argparse.py for details.

Suggested-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: John Snow <jsnow@redhat.com>
Message-id: 20170825155732.15665-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 COPYING.PYTHON      |  270 ++++++
 scripts/argparse.py | 2406 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 2676 insertions(+)
 create mode 100644 COPYING.PYTHON
 create mode 100644 scripts/argparse.py

diff --git a/COPYING.PYTHON b/COPYING.PYTHON
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/COPYING.PYTHON
@@ -XXX,XX +XXX,XX @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations (now Zope
+Corporation, see http://www.zope.com).  In 2001, the Python Software
+Foundation (PSF, see http://www.python.org/psf/) was formed, a
+non-profit organization created specifically to own Python-related
+Intellectual Property.  Zope Corporation is a sponsoring member of
+the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.2             2.1.1       2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2.1           2.2         2002        PSF         yes
+    2.2.2           2.2.1       2002        PSF         yes
+    2.2.3           2.2.2       2003        PSF         yes
+    2.3             2.2.2       2002-2003   PSF         yes
+    2.3.1           2.3         2002-2003   PSF         yes
+    2.3.2           2.3.1       2002-2003   PSF         yes
+    2.3.3           2.3.2       2002-2003   PSF         yes
+    2.3.4           2.3.3       2004        PSF         yes
+    2.3.5           2.3.4       2005        PSF         yes
+    2.4             2.3         2004        PSF         yes
+    2.4.1           2.4         2005        PSF         yes
+    2.4.2           2.4.1       2005        PSF         yes
+    2.4.3           2.4.2       2006        PSF         yes
+    2.5             2.4         2006        PSF         yes
+    2.7             2.6         2010        PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python
+alone or in any derivative version, provided, however, that PSF's
+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
+2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights
+Reserved" are retained in Python alone or in any derivative version 
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/scripts/argparse.py b/scripts/argparse.py
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/scripts/argparse.py
@@ -XXX,XX +XXX,XX @@
+# This is a local copy of the standard library argparse module taken from PyPI.
+# It is licensed under the Python Software Foundation License.  This is a
+# fallback for Python 2.6 which does not include this module.  Python 2.7+ and
+# 3+ will never load this module because built-in modules are loaded before
+# anything in sys.path.
+#
+# If your script is not located in the same directory as this file, import it
+# like this:
+#
+#   import os
+#   import sys
+#   sys.path.append(os.path.join(os.path.dirname(__file__), ..., 'scripts'))
+#   import argparse
+
+# Author: Steven J. Bethard <steven.bethard@gmail.com>.
+# Maintainer: Thomas Waldmann <tw@waldmann-edv.de>
+
+"""Command-line parsing library
+
+This module is an optparse-inspired command-line parsing library that:
+
+    - handles both optional and positional arguments
+    - produces highly informative usage messages
+    - supports parsers that dispatch to sub-parsers
+
+The following is a simple usage example that sums integers from the
+command-line and writes the result to a file::
+
+    parser = argparse.ArgumentParser(
+        description='sum the integers at the command line')
+    parser.add_argument(
+        'integers', metavar='int', nargs='+', type=int,
+        help='an integer to be summed')
+    parser.add_argument(
+        '--log', default=sys.stdout, type=argparse.FileType('w'),
+        help='the file where the sum should be written')
+    args = parser.parse_args()
+    args.log.write('%s' % sum(args.integers))
+    args.log.close()
+
+The module contains the following public classes:
+
+    - ArgumentParser -- The main entry point for command-line parsing. As the
+        example above shows, the add_argument() method is used to populate
+        the parser with actions for optional and positional arguments. Then
+        the parse_args() method is invoked to convert the args at the
+        command-line into an object with attributes.
+
+    - ArgumentError -- The exception raised by ArgumentParser objects when
+        there are errors with the parser's actions. Errors raised while
+        parsing the command-line are caught by ArgumentParser and emitted
+        as command-line messages.
+
+    - FileType -- A factory for defining types of files to be created. As the
+        example above shows, instances of FileType are typically passed as
+        the type= argument of add_argument() calls.
+
+    - Action -- The base class for parser actions. Typically actions are
+        selected by passing strings like 'store_true' or 'append_const' to
+        the action= argument of add_argument(). However, for greater
+        customization of ArgumentParser actions, subclasses of Action may
+        be defined and passed as the action= argument.
+
+    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
+        ArgumentDefaultsHelpFormatter -- Formatter classes which
+        may be passed as the formatter_class= argument to the
+        ArgumentParser constructor. HelpFormatter is the default,
+        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
+        not to change the formatting for help text, and
+        ArgumentDefaultsHelpFormatter adds information about argument defaults
+        to the help.
+
+All other classes in this module are considered implementation details.
+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
+considered public as object names -- the API of the formatter objects is
+still considered an implementation detail.)
+"""
+
+__version__ = '1.4.0'  # we use our own version number independant of the
+                       # one in stdlib and we release this on pypi.
+
+__external_lib__ = True  # to make sure the tests really test THIS lib,
+                         # not the builtin one in Python stdlib
+
+__all__ = [
+    'ArgumentParser',
+    'ArgumentError',
+    'ArgumentTypeError',
+    'FileType',
+    'HelpFormatter',
+    'ArgumentDefaultsHelpFormatter',
+    'RawDescriptionHelpFormatter',
+    'RawTextHelpFormatter',
+    'Namespace',
+    'Action',
+    'ONE_OR_MORE',
+    'OPTIONAL',
+    'PARSER',
+    'REMAINDER',
+    'SUPPRESS',
+    'ZERO_OR_MORE',
+]
+
+
+import copy as _copy
+import os as _os
+import re as _re
+import sys as _sys
+import textwrap as _textwrap
+
+from gettext import gettext as _
+
+try:
+    set
+except NameError:
+    # for python < 2.4 compatibility (sets module is there since 2.3):
+    from sets import Set as set
+
+try:
+    basestring
+except NameError:
+    basestring = str
+
+try:
+    sorted
+except NameError:
+    # for python < 2.4 compatibility:
+    def sorted(iterable, reverse=False):
+        result = list(iterable)
+        result.sort()
+        if reverse:
+            result.reverse()
+        return result
+
+
+def _callable(obj):
+    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
+
+
+SUPPRESS = '==SUPPRESS=='
+
+OPTIONAL = '?'
+ZERO_OR_MORE = '*'
+ONE_OR_MORE = '+'
+PARSER = 'A...'
+REMAINDER = '...'
+_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
+
+# =============================
+# Utility functions and classes
+# =============================
+
+class _AttributeHolder(object):
+    """Abstract base class that provides __repr__.
+
+    The __repr__ method returns a string in the format::
+        ClassName(attr=name, attr=name, ...)
+    The attributes are determined either by a class-level attribute,
+    '_kwarg_names', or by inspecting the instance __dict__.
+    """
+
+    def __repr__(self):
+        type_name = type(self).__name__
+        arg_strings = []
+        for arg in self._get_args():
+            arg_strings.append(repr(arg))
+        for name, value in self._get_kwargs():
+            arg_strings.append('%s=%r' % (name, value))
+        return '%s(%s)' % (type_name, ', '.join(arg_strings))
+
+    def _get_kwargs(self):
+        return sorted(self.__dict__.items())
+
+    def _get_args(self):
+        return []
+
+
+def _ensure_value(namespace, name, value):
+    if getattr(namespace, name, None) is None:
+        setattr(namespace, name, value)
+    return getattr(namespace, name)
+
+
+# ===============
+# Formatting Help
+# ===============
+
+class HelpFormatter(object):
+    """Formatter for generating usage messages and argument help strings.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def __init__(self,
+                 prog,
+                 indent_increment=2,
+                 max_help_position=24,
+                 width=None):
+
+        # default setting for width
+        if width is None:
+            try:
+                width = int(_os.environ['COLUMNS'])
+            except (KeyError, ValueError):
+                width = 80
+            width -= 2
+
+        self._prog = prog
+        self._indent_increment = indent_increment
+        self._max_help_position = max_help_position
+        self._width = width
+
+        self._current_indent = 0
+        self._level = 0
+        self._action_max_length = 0
+
+        self._root_section = self._Section(self, None)
+        self._current_section = self._root_section
+
+        self._whitespace_matcher = _re.compile(r'\s+')
+        self._long_break_matcher = _re.compile(r'\n\n\n+')
+
+    # ===============================
+    # Section and indentation methods
+    # ===============================
+    def _indent(self):
+        self._current_indent += self._indent_increment
+        self._level += 1
+
+    def _dedent(self):
+        self._current_indent -= self._indent_increment
+        assert self._current_indent >= 0, 'Indent decreased below 0.'
+        self._level -= 1
+
+    class _Section(object):
+
+        def __init__(self, formatter, parent, heading=None):
+            self.formatter = formatter
+            self.parent = parent
+            self.heading = heading
+            self.items = []
+
+        def format_help(self):
+            # format the indented section
+            if self.parent is not None:
+                self.formatter._indent()
+            join = self.formatter._join_parts
+            for func, args in self.items:
+                func(*args)
+            item_help = join([func(*args) for func, args in self.items])
+            if self.parent is not None:
+                self.formatter._dedent()
+
+            # return nothing if the section was empty
+            if not item_help:
+                return ''
+
+            # add the heading if the section was non-empty
+            if self.heading is not SUPPRESS and self.heading is not None:
+                current_indent = self.formatter._current_indent
+                heading = '%*s%s:\n' % (current_indent, '', self.heading)
+            else:
+                heading = ''
+
+            # join the section-initial newline, the heading and the help
+            return join(['\n', heading, item_help, '\n'])
+
+    def _add_item(self, func, args):
+        self._current_section.items.append((func, args))
+
+    # ========================
+    # Message building methods
+    # ========================
+    def start_section(self, heading):
+        self._indent()
+        section = self._Section(self, self._current_section, heading)
+        self._add_item(section.format_help, [])
+        self._current_section = section
+
+    def end_section(self):
+        self._current_section = self._current_section.parent
+        self._dedent()
+
+    def add_text(self, text):
+        if text is not SUPPRESS and text is not None:
+            self._add_item(self._format_text, [text])
+
+    def add_usage(self, usage, actions, groups, prefix=None):
+        if usage is not SUPPRESS:
+            args = usage, actions, groups, prefix
+            self._add_item(self._format_usage, args)
+
+    def add_argument(self, action):
+        if action.help is not SUPPRESS:
+
+            # find all invocations
+            get_invocation = self._format_action_invocation
+            invocations = [get_invocation(action)]
+            for subaction in self._iter_indented_subactions(action):
+                invocations.append(get_invocation(subaction))
+
+            # update the maximum item length
+            invocation_length = max([len(s) for s in invocations])
+            action_length = invocation_length + self._current_indent
+            self._action_max_length = max(self._action_max_length,
+                                          action_length)
+
+            # add the item to the list
+            self._add_item(self._format_action, [action])
+
+    def add_arguments(self, actions):
+        for action in actions:
+            self.add_argument(action)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_help(self):
+        help = self._root_section.format_help()
+        if help:
+            help = self._long_break_matcher.sub('\n\n', help)
+            help = help.strip('\n') + '\n'
+        return help
+
+    def _join_parts(self, part_strings):
+        return ''.join([part
+                        for part in part_strings
+                        if part and part is not SUPPRESS])
+
+    def _format_usage(self, usage, actions, groups, prefix):
+        if prefix is None:
+            prefix = _('usage: ')
+
+        # if usage is specified, use that
+        if usage is not None:
+            usage = usage % dict(prog=self._prog)
+
+        # if no optionals or positionals are available, usage is just prog
+        elif usage is None and not actions:
+            usage = '%(prog)s' % dict(prog=self._prog)
+
+        # if optionals and positionals are available, calculate usage
+        elif usage is None:
+            prog = '%(prog)s' % dict(prog=self._prog)
+
+            # split optionals from positionals
+            optionals = []
+            positionals = []
+            for action in actions:
+                if action.option_strings:
+                    optionals.append(action)
+                else:
+                    positionals.append(action)
+
+            # build full usage string
+            format = self._format_actions_usage
+            action_usage = format(optionals + positionals, groups)
+            usage = ' '.join([s for s in [prog, action_usage] if s])
+
+            # wrap the usage parts if it's too long
+            text_width = self._width - self._current_indent
+            if len(prefix) + len(usage) > text_width:
+
+                # break usage into wrappable parts
+                part_regexp = r'$.*?$+|\[.*?\]+|\S+'
+                opt_usage = format(optionals, groups)
+                pos_usage = format(positionals, groups)
+                opt_parts = _re.findall(part_regexp, opt_usage)
+                pos_parts = _re.findall(part_regexp, pos_usage)
+                assert ' '.join(opt_parts) == opt_usage
+                assert ' '.join(pos_parts) == pos_usage
+
+                # helper for wrapping lines
+                def get_lines(parts, indent, prefix=None):
+                    lines = []
+                    line = []
+                    if prefix is not None:
+                        line_len = len(prefix) - 1
+                    else:
+                        line_len = len(indent) - 1
+                    for part in parts:
+                        if line_len + 1 + len(part) > text_width:
+                            lines.append(indent + ' '.join(line))
+                            line = []
+                            line_len = len(indent) - 1
+                        line.append(part)
+                        line_len += len(part) + 1
+                    if line:
+                        lines.append(indent + ' '.join(line))
+                    if prefix is not None:
+                        lines[0] = lines[0][len(indent):]
+                    return lines
+
+                # if prog is short, follow it with optionals or positionals
+                if len(prefix) + len(prog) <= 0.75 * text_width:
+                    indent = ' ' * (len(prefix) + len(prog) + 1)
+                    if opt_parts:
+                        lines = get_lines([prog] + opt_parts, indent, prefix)
+                        lines.extend(get_lines(pos_parts, indent))
+                    elif pos_parts:
+                        lines = get_lines([prog] + pos_parts, indent, prefix)
+                    else:
+                        lines = [prog]
+
+                # if prog is long, put it on its own line
+                else:
+                    indent = ' ' * len(prefix)
+                    parts = opt_parts + pos_parts
+                    lines = get_lines(parts, indent)
+                    if len(lines) > 1:
+                        lines = []
+                        lines.extend(get_lines(opt_parts, indent))
+                        lines.extend(get_lines(pos_parts, indent))
+                    lines = [prog] + lines
+
+                # join lines into usage
+                usage = '\n'.join(lines)
+
+        # prefix with 'usage:'
+        return '%s%s\n\n' % (prefix, usage)
+
+    def _format_actions_usage(self, actions, groups):
+        # find group indices and identify actions in groups
+        group_actions = set()
+        inserts = {}
+        for group in groups:
+            try:
+                start = actions.index(group._group_actions[0])
+            except ValueError:
+                continue
+            else:
+                end = start + len(group._group_actions)
+                if actions[start:end] == group._group_actions:
+                    for action in group._group_actions:
+                        group_actions.add(action)
+                    if not group.required:
+                        if start in inserts:
+                            inserts[start] += ' ['
+                        else:
+                            inserts[start] = '['
+                        inserts[end] = ']'
+                    else:
+                        if start in inserts:
+                            inserts[start] += ' ('
+                        else:
+                            inserts[start] = '('
+                        inserts[end] = ')'
+                    for i in range(start + 1, end):
+                        inserts[i] = '|'
+
+        # collect all actions format strings
+        parts = []
+        for i, action in enumerate(actions):
+
+            # suppressed arguments are marked with None
+            # remove | separators for suppressed arguments
+            if action.help is SUPPRESS:
+                parts.append(None)
+                if inserts.get(i) == '|':
+                    inserts.pop(i)
+                elif inserts.get(i + 1) == '|':
+                    inserts.pop(i + 1)
+
+            # produce all arg strings
+            elif not action.option_strings:
+                part = self._format_args(action, action.dest)
+
+                # if it's in a group, strip the outer []
+                if action in group_actions:
+                    if part[0] == '[' and part[-1] == ']':
+                        part = part[1:-1]
+
+                # add the action string to the list
+                parts.append(part)
+
+            # produce the first way to invoke the option in brackets
+            else:
+                option_string = action.option_strings[0]
+
+                # if the Optional doesn't take a value, format is:
+                #    -s or --long
+                if action.nargs == 0:
+                    part = '%s' % option_string
+
+                # if the Optional takes a value, format is:
+                #    -s ARGS or --long ARGS
+                else:
+                    default = action.dest.upper()
+                    args_string = self._format_args(action, default)
+                    part = '%s %s' % (option_string, args_string)
+
+                # make it look optional if it's not required or in a group
+                if not action.required and action not in group_actions:
+                    part = '[%s]' % part
+
+                # add the action string to the list
+                parts.append(part)
+
+        # insert things at the necessary indices
+        for i in sorted(inserts, reverse=True):
+            parts[i:i] = [inserts[i]]
+
+        # join all the action items with spaces
+        text = ' '.join([item for item in parts if item is not None])
+
+        # clean up separators for mutually exclusive groups
+        open = r'[\[(]'
+        close = r'[\])]'
+        text = _re.sub(r'(%s) ' % open, r'\1', text)
+        text = _re.sub(r' (%s)' % close, r'\1', text)
+        text = _re.sub(r'%s *%s' % (open, close), r'', text)
+        text = _re.sub(r'$([^|]*)$', r'\1', text)
+        text = text.strip()
+
+        # return the text
+        return text
+
+    def _format_text(self, text):
+        if '%(prog)' in text:
+            text = text % dict(prog=self._prog)
+        text_width = self._width - self._current_indent
+        indent = ' ' * self._current_indent
+        return self._fill_text(text, text_width, indent) + '\n\n'
+
+    def _format_action(self, action):
+        # determine the required width and the entry label
+        help_position = min(self._action_max_length + 2,
+                            self._max_help_position)
+        help_width = self._width - help_position
+        action_width = help_position - self._current_indent - 2
+        action_header = self._format_action_invocation(action)
+
+        # ho nelp; start on same line and add a final newline
+        if not action.help:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+
+        # short action name; start on the same line and pad two spaces
+        elif len(action_header) <= action_width:
+            tup = self._current_indent, '', action_width, action_header
+            action_header = '%*s%-*s  ' % tup
+            indent_first = 0
+
+        # long action name; start on the next line
+        else:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+            indent_first = help_position
+
+        # collect the pieces of the action help
+        parts = [action_header]
+
+        # if there was help for the action, add lines of help text
+        if action.help:
+            help_text = self._expand_help(action)
+            help_lines = self._split_lines(help_text, help_width)
+            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
+            for line in help_lines[1:]:
+                parts.append('%*s%s\n' % (help_position, '', line))
+
+        # or add a newline if the description doesn't end with one
+        elif not action_header.endswith('\n'):
+            parts.append('\n')
+
+        # if there are any sub-actions, add their help as well
+        for subaction in self._iter_indented_subactions(action):
+            parts.append(self._format_action(subaction))
+
+        # return a single string
+        return self._join_parts(parts)
+
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+
+        else:
+            parts = []
+
+            # if the Optional doesn't take a value, format is:
+            #    -s, --long
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+
+            # if the Optional takes a value, format is:
+            #    -s ARGS, --long ARGS
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                for option_string in action.option_strings:
+                    parts.append('%s %s' % (option_string, args_string))
+
+            return ', '.join(parts)
+
+    def _metavar_formatter(self, action, default_metavar):
+        if action.metavar is not None:
+            result = action.metavar
+        elif action.choices is not None:
+            choice_strs = [str(choice) for choice in action.choices]
+            result = '{%s}' % ','.join(choice_strs)
+        else:
+            result = default_metavar
+
+        def format(tuple_size):
+            if isinstance(result, tuple):
+                return result
+            else:
+                return (result, ) * tuple_size
+        return format
+
+    def _format_args(self, action, default_metavar):
+        get_metavar = self._metavar_formatter(action, default_metavar)
+        if action.nargs is None:
+            result = '%s' % get_metavar(1)
+        elif action.nargs == OPTIONAL:
+            result = '[%s]' % get_metavar(1)
+        elif action.nargs == ZERO_OR_MORE:
+            result = '[%s [%s ...]]' % get_metavar(2)
+        elif action.nargs == ONE_OR_MORE:
+            result = '%s [%s ...]' % get_metavar(2)
+        elif action.nargs == REMAINDER:
+            result = '...'
+        elif action.nargs == PARSER:
+            result = '%s ...' % get_metavar(1)
+        else:
+            formats = ['%s' for _ in range(action.nargs)]
+            result = ' '.join(formats) % get_metavar(action.nargs)
+        return result
+
+    def _expand_help(self, action):
+        params = dict(vars(action), prog=self._prog)
+        for name in list(params):
+            if params[name] is SUPPRESS:
+                del params[name]
+        for name in list(params):
+            if hasattr(params[name], '__name__'):
+                params[name] = params[name].__name__
+        if params.get('choices') is not None:
+            choices_str = ', '.join([str(c) for c in params['choices']])
+            params['choices'] = choices_str
+        return self._get_help_string(action) % params
+
+    def _iter_indented_subactions(self, action):
+        try:
+            get_subactions = action._get_subactions
+        except AttributeError:
+            pass
+        else:
+            self._indent()
+            for subaction in get_subactions():
+                yield subaction
+            self._dedent()
+
+    def _split_lines(self, text, width):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.wrap(text, width)
+
+    def _fill_text(self, text, width, indent):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.fill(text, width, initial_indent=indent,
+                                           subsequent_indent=indent)
+
+    def _get_help_string(self, action):
+        return action.help
+
+
+class RawDescriptionHelpFormatter(HelpFormatter):
+    """Help message formatter which retains any formatting in descriptions.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _fill_text(self, text, width, indent):
+        return ''.join([indent + line for line in text.splitlines(True)])
+
+
+class RawTextHelpFormatter(RawDescriptionHelpFormatter):
+    """Help message formatter which retains formatting of all help text.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _split_lines(self, text, width):
+        return text.splitlines()
+
+
+class ArgumentDefaultsHelpFormatter(HelpFormatter):
+    """Help message formatter which adds default values to argument help.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _get_help_string(self, action):
+        help = action.help
+        if '%(default)' not in action.help:
+            if action.default is not SUPPRESS:
+                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
+                if action.option_strings or action.nargs in defaulting_nargs:
+                    help += ' (default: %(default)s)'
+        return help
+
+
+# =====================
+# Options and Arguments
+# =====================
+
+def _get_action_name(argument):
+    if argument is None:
+        return None
+    elif argument.option_strings:
+        return  '/'.join(argument.option_strings)
+    elif argument.metavar not in (None, SUPPRESS):
+        return argument.metavar
+    elif argument.dest not in (None, SUPPRESS):
+        return argument.dest
+    else:
+        return None
+
+
+class ArgumentError(Exception):
+    """An error from creating or using an argument (optional or positional).
+
+    The string value of this exception is the message, augmented with
+    information about the argument that caused it.
+    """
+
+    def __init__(self, argument, message):
+        self.argument_name = _get_action_name(argument)
+        self.message = message
+
+    def __str__(self):
+        if self.argument_name is None:
+            format = '%(message)s'
+        else:
+            format = 'argument %(argument_name)s: %(message)s'
+        return format % dict(message=self.message,
+                             argument_name=self.argument_name)
+
+
+class ArgumentTypeError(Exception):
+    """An error from trying to convert a command line string to a type."""
+    pass
+
+
+# ==============
+# Action classes
+# ==============
+
+class Action(_AttributeHolder):
+    """Information about how to convert command line strings to Python objects.
+
+    Action objects are used by an ArgumentParser to represent the information
+    needed to parse a single argument from one or more strings from the
+    command line. The keyword arguments to the Action constructor are also
+    all attributes of Action instances.
+
+    Keyword Arguments:
+
+        - option_strings -- A list of command-line option strings which
+            should be associated with this action.
+
+        - dest -- The name of the attribute to hold the created object(s)
+
+        - nargs -- The number of command-line arguments that should be
+            consumed. By default, one argument will be consumed and a single
+            value will be produced.  Other values include:
+                - N (an integer) consumes N arguments (and produces a list)
+                - '?' consumes zero or one arguments
+                - '*' consumes zero or more arguments (and produces a list)
+                - '+' consumes one or more arguments (and produces a list)
+            Note that the difference between the default and nargs=1 is that
+            with the default, a single value will be produced, while with
+            nargs=1, a list containing a single value will be produced.
+
+        - const -- The value to be produced if the option is specified and the
+            option uses an action that takes no values.
+
+        - default -- The value to be produced if the option is not specified.
+
+        - type -- The type which the command-line arguments should be converted
+            to, should be one of 'string', 'int', 'float', 'complex' or a
+            callable object that accepts a single string argument. If None,
+            'string' is assumed.
+
+        - choices -- A container of values that should be allowed. If not None,
+            after a command-line argument has been converted to the appropriate
+            type, an exception will be raised if it is not a member of this
+            collection.
+
+        - required -- True if the action must always be specified at the
+            command line. This is only meaningful for optional command-line
+            arguments.
+
+        - help -- The help string describing the argument.
+
+        - metavar -- The name to be used for the option's argument with the
+            help string. If None, the 'dest' value will be used as the name.
+    """
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        self.option_strings = option_strings
+        self.dest = dest
+        self.nargs = nargs
+        self.const = const
+        self.default = default
+        self.type = type
+        self.choices = choices
+        self.required = required
+        self.help = help
+        self.metavar = metavar
+
+    def _get_kwargs(self):
+        names = [
+            'option_strings',
+            'dest',
+            'nargs',
+            'const',
+            'default',
+            'type',
+            'choices',
+            'help',
+            'metavar',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        raise NotImplementedError(_('.__call__() not defined'))
+
+
+class _StoreAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for store actions must be > 0; if you '
+                             'have nothing to store, actions such as store '
+                             'true or store const may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_StoreAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, values)
+
+
+class _StoreConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_StoreConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, self.const)
+
+
+class _StoreTrueAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=False,
+                 required=False,
+                 help=None):
+        super(_StoreTrueAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=True,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _StoreFalseAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=True,
+                 required=False,
+                 help=None):
+        super(_StoreFalseAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=False,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _AppendAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for append actions must be > 0; if arg '
+                             'strings are not supplying the value to append, '
+                             'the append const action may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_AppendAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(values)
+        setattr(namespace, self.dest, items)
+
+
+class _AppendConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_AppendConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(self.const)
+        setattr(namespace, self.dest, items)
+
+
+class _CountAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=None,
+                 required=False,
+                 help=None):
+        super(_CountAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        new_count = _ensure_value(namespace, self.dest, 0) + 1
+        setattr(namespace, self.dest, new_count)
+
+
+class _HelpAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help=None):
+        super(_HelpAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser.print_help()
+        parser.exit()
+
+
+class _VersionAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 version=None,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help="show program's version number and exit"):
+        super(_VersionAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+        self.version = version
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        version = self.version
+        if version is None:
+            version = parser.version
+        formatter = parser._get_formatter()
+        formatter.add_text(version)
+        parser.exit(message=formatter.format_help())
+
+
+class _SubParsersAction(Action):
+
+    class _ChoicesPseudoAction(Action):
+
+        def __init__(self, name, aliases, help):
+            metavar = dest = name
+            if aliases:
+                metavar += ' (%s)' % ', '.join(aliases)
+            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
+            sup.__init__(option_strings=[], dest=dest, help=help,
+                        metavar=metavar)
+
+    def __init__(self,
+                 option_strings,
+                 prog,
+                 parser_class,
+                 dest=SUPPRESS,
+                 help=None,
+                 metavar=None):
+
+        self._prog_prefix = prog
+        self._parser_class = parser_class
+        self._name_parser_map = {}
+        self._choices_actions = []
+
+        super(_SubParsersAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=PARSER,
+            choices=self._name_parser_map,
+            help=help,
+            metavar=metavar)
+
+    def add_parser(self, name, **kwargs):
+        # set prog from the existing prefix
+        if kwargs.get('prog') is None:
+            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
+
+        aliases = kwargs.pop('aliases', ())
+
+        # create a pseudo-action to hold the choice help
+        if 'help' in kwargs:
+            help = kwargs.pop('help')
+            choice_action = self._ChoicesPseudoAction(name, aliases, help)
+            self._choices_actions.append(choice_action)
+
+        # create the parser and add it to the map
+        parser = self._parser_class(**kwargs)
+        self._name_parser_map[name] = parser
+
+        # make parser available under aliases also
+        for alias in aliases:
+            self._name_parser_map[alias] = parser
+
+        return parser
+
+    def _get_subactions(self):
+        return self._choices_actions
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser_name = values[0]
+        arg_strings = values[1:]
+
+        # set the parser name if requested
+        if self.dest is not SUPPRESS:
+            setattr(namespace, self.dest, parser_name)
+
+        # select the parser
+        try:
+            parser = self._name_parser_map[parser_name]
+        except KeyError:
+            tup = parser_name, ', '.join(self._name_parser_map)
+            msg = _('unknown parser %r (choices: %s)' % tup)
+            raise ArgumentError(self, msg)
+
+        # parse all the remaining options into the namespace
+        # store any unrecognized options on the object, so that the top
+        # level parser can decide what to do with them
+        namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
+        if arg_strings:
+            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
+            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
+
+
+# ==============
+# Type classes
+# ==============
+
+class FileType(object):
+    """Factory for creating file object types
+
+    Instances of FileType are typically passed as type= arguments to the
+    ArgumentParser add_argument() method.
+
+    Keyword Arguments:
+        - mode -- A string indicating how the file is to be opened. Accepts the
+            same values as the builtin open() function.
+        - bufsize -- The file's desired buffer size. Accepts the same values as
+            the builtin open() function.
+    """
+
+    def __init__(self, mode='r', bufsize=None):
+        self._mode = mode
+        self._bufsize = bufsize
+
+    def __call__(self, string):
+        # the special argument "-" means sys.std{in,out}
+        if string == '-':
+            if 'r' in self._mode:
+                return _sys.stdin
+            elif 'w' in self._mode:
+                return _sys.stdout
+            else:
+                msg = _('argument "-" with mode %r' % self._mode)
+                raise ValueError(msg)
+
+        try:
+            # all other arguments are used as file names
+            if self._bufsize:
+                return open(string, self._mode, self._bufsize)
+            else:
+                return open(string, self._mode)
+        except IOError:
+            err = _sys.exc_info()[1]
+            message = _("can't open '%s': %s")
+            raise ArgumentTypeError(message % (string, err))
+
+    def __repr__(self):
+        args = [self._mode, self._bufsize]
+        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
+        return '%s(%s)' % (type(self).__name__, args_str)
+
+# ===========================
+# Optional and Positional Parsing
+# ===========================
+
+class Namespace(_AttributeHolder):
+    """Simple object for storing attributes.
+
+    Implements equality by attribute names and values, and provides a simple
+    string representation.
+    """
+
+    def __init__(self, **kwargs):
+        for name in kwargs:
+            setattr(self, name, kwargs[name])
+
+    __hash__ = None
+
+    def __eq__(self, other):
+        return vars(self) == vars(other)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __contains__(self, key):
+        return key in self.__dict__
+
+
+class _ActionsContainer(object):
+
+    def __init__(self,
+                 description,
+                 prefix_chars,
+                 argument_default,
+                 conflict_handler):
+        super(_ActionsContainer, self).__init__()
+
+        self.description = description
+        self.argument_default = argument_default
+        self.prefix_chars = prefix_chars
+        self.conflict_handler = conflict_handler
+
+        # set up registries
+        self._registries = {}
+
+        # register actions
+        self.register('action', None, _StoreAction)
+        self.register('action', 'store', _StoreAction)
+        self.register('action', 'store_const', _StoreConstAction)
+        self.register('action', 'store_true', _StoreTrueAction)
+        self.register('action', 'store_false', _StoreFalseAction)
+        self.register('action', 'append', _AppendAction)
+        self.register('action', 'append_const', _AppendConstAction)
+        self.register('action', 'count', _CountAction)
+        self.register('action', 'help', _HelpAction)
+        self.register('action', 'version', _VersionAction)
+        self.register('action', 'parsers', _SubParsersAction)
+
+        # raise an exception if the conflict handler is invalid
+        self._get_handler()
+
+        # action storage
+        self._actions = []
+        self._option_string_actions = {}
+
+        # groups
+        self._action_groups = []
+        self._mutually_exclusive_groups = []
+
+        # defaults storage
+        self._defaults = {}
+
+        # determines whether an "option" looks like a negative number
+        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
+
+        # whether or not there are any optionals that look like negative
+        # numbers -- uses a list so it can be shared and edited
+        self._has_negative_number_optionals = []
+
+    # ====================
+    # Registration methods
+    # ====================
+    def register(self, registry_name, value, object):
+        registry = self._registries.setdefault(registry_name, {})
+        registry[value] = object
+
+    def _registry_get(self, registry_name, value, default=None):
+        return self._registries[registry_name].get(value, default)
+
+    # ==================================
+    # Namespace default accessor methods
+    # ==================================
+    def set_defaults(self, **kwargs):
+        self._defaults.update(kwargs)
+
+        # if these defaults match any existing arguments, replace
+        # the previous default on the object with the new one
+        for action in self._actions:
+            if action.dest in kwargs:
+                action.default = kwargs[action.dest]
+
+    def get_default(self, dest):
+        for action in self._actions:
+            if action.dest == dest and action.default is not None:
+                return action.default
+        return self._defaults.get(dest, None)
+
+
+    # =======================
+    # Adding argument actions
+    # =======================
+    def add_argument(self, *args, **kwargs):
+        """
+        add_argument(dest, ..., name=value, ...)
+        add_argument(option_string, option_string, ..., name=value, ...)
+        """
+
+        # if no positional args are supplied or only one is supplied and
+        # it doesn't look like an option string, parse a positional
+        # argument
+        chars = self.prefix_chars
+        if not args or len(args) == 1 and args[0][0] not in chars:
+            if args and 'dest' in kwargs:
+                raise ValueError('dest supplied twice for positional argument')
+            kwargs = self._get_positional_kwargs(*args, **kwargs)
+
+        # otherwise, we're adding an optional argument
+        else:
+            kwargs = self._get_optional_kwargs(*args, **kwargs)
+
+        # if no default was supplied, use the parser-level default
+        if 'default' not in kwargs:
+            dest = kwargs['dest']
+            if dest in self._defaults:
+                kwargs['default'] = self._defaults[dest]
+            elif self.argument_default is not None:
+                kwargs['default'] = self.argument_default
+
+        # create the action object, and add it to the parser
+        action_class = self._pop_action_class(kwargs)
+        if not _callable(action_class):
+            raise ValueError('unknown action "%s"' % action_class)
+        action = action_class(**kwargs)
+
+        # raise an error if the action type is not callable
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            raise ValueError('%r is not callable' % type_func)
+
+        return self._add_action(action)
+
+    def add_argument_group(self, *args, **kwargs):
+        group = _ArgumentGroup(self, *args, **kwargs)
+        self._action_groups.append(group)
+        return group
+
+    def add_mutually_exclusive_group(self, **kwargs):
+        group = _MutuallyExclusiveGroup(self, **kwargs)
+        self._mutually_exclusive_groups.append(group)
+        return group
+
+    def _add_action(self, action):
+        # resolve any conflicts
+        self._check_conflict(action)
+
+        # add to actions list
+        self._actions.append(action)
+        action.container = self
+
+        # index the action by any option strings it has
+        for option_string in action.option_strings:
+            self._option_string_actions[option_string] = action
+
+        # set the flag if any option strings look like negative numbers
+        for option_string in action.option_strings:
+            if self._negative_number_matcher.match(option_string):
+                if not self._has_negative_number_optionals:
+                    self._has_negative_number_optionals.append(True)
+
+        # return the created action
+        return action
+
+    def _remove_action(self, action):
+        self._actions.remove(action)
+
+    def _add_container_actions(self, container):
+        # collect groups by titles
+        title_group_map = {}
+        for group in self._action_groups:
+            if group.title in title_group_map:
+                msg = _('cannot merge actions - two groups are named %r')
+                raise ValueError(msg % (group.title))
+            title_group_map[group.title] = group
+
+        # map each action to its group
+        group_map = {}
+        for group in container._action_groups:
+
+            # if a group with the title exists, use that, otherwise
+            # create a new group matching the container's group
+            if group.title not in title_group_map:
+                title_group_map[group.title] = self.add_argument_group(
+                    title=group.title,
+                    description=group.description,
+                    conflict_handler=group.conflict_handler)
+
+            # map the actions to their new group
+            for action in group._group_actions:
+                group_map[action] = title_group_map[group.title]
+
+        # add container's mutually exclusive groups
+        # NOTE: if add_mutually_exclusive_group ever gains title= and
+        # description= then this code will need to be expanded as above
+        for group in container._mutually_exclusive_groups:
+            mutex_group = self.add_mutually_exclusive_group(
+                required=group.required)
+
+            # map the actions to their new mutex group
+            for action in group._group_actions:
+                group_map[action] = mutex_group
+
+        # add all actions to this container or their group
+        for action in container._actions:
+            group_map.get(action, self)._add_action(action)
+
+    def _get_positional_kwargs(self, dest, **kwargs):
+        # make sure required is not specified
+        if 'required' in kwargs:
+            msg = _("'required' is an invalid argument for positionals")
+            raise TypeError(msg)
+
+        # mark positional arguments as required if at least one is
+        # always required
+        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
+            kwargs['required'] = True
+        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
+            kwargs['required'] = True
+
+        # return the keyword arguments with no option strings
+        return dict(kwargs, dest=dest, option_strings=[])
+
+    def _get_optional_kwargs(self, *args, **kwargs):
+        # determine short and long option strings
+        option_strings = []
+        long_option_strings = []
+        for option_string in args:
+            # error on strings that don't start with an appropriate prefix
+            if not option_string[0] in self.prefix_chars:
+                msg = _('invalid option string %r: '
+                        'must start with a character %r')
+                tup = option_string, self.prefix_chars
+                raise ValueError(msg % tup)
+
+            # strings starting with two prefix characters are long options
+            option_strings.append(option_string)
+            if option_string[0] in self.prefix_chars:
+                if len(option_string) > 1:
+                    if option_string[1] in self.prefix_chars:
+                        long_option_strings.append(option_string)
+
+        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
+        dest = kwargs.pop('dest', None)
+        if dest is None:
+            if long_option_strings:
+                dest_option_string = long_option_strings[0]
+            else:
+                dest_option_string = option_strings[0]
+            dest = dest_option_string.lstrip(self.prefix_chars)
+            if not dest:
+                msg = _('dest= is required for options like %r')
+                raise ValueError(msg % option_string)
+            dest = dest.replace('-', '_')
+
+        # return the updated keyword arguments
+        return dict(kwargs, dest=dest, option_strings=option_strings)
+
+    def _pop_action_class(self, kwargs, default=None):
+        action = kwargs.pop('action', default)
+        return self._registry_get('action', action, action)
+
+    def _get_handler(self):
+        # determine function from conflict handler string
+        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
+        try:
+            return getattr(self, handler_func_name)
+        except AttributeError:
+            msg = _('invalid conflict_resolution value: %r')
+            raise ValueError(msg % self.conflict_handler)
+
+    def _check_conflict(self, action):
+
+        # find all options that conflict with this option
+        confl_optionals = []
+        for option_string in action.option_strings:
+            if option_string in self._option_string_actions:
+                confl_optional = self._option_string_actions[option_string]
+                confl_optionals.append((option_string, confl_optional))
+
+        # resolve any conflicts
+        if confl_optionals:
+            conflict_handler = self._get_handler()
+            conflict_handler(action, confl_optionals)
+
+    def _handle_conflict_error(self, action, conflicting_actions):
+        message = _('conflicting option string(s): %s')
+        conflict_string = ', '.join([option_string
+                                     for option_string, action
+                                     in conflicting_actions])
+        raise ArgumentError(action, message % conflict_string)
+
+    def _handle_conflict_resolve(self, action, conflicting_actions):
+
+        # remove all conflicting options
+        for option_string, action in conflicting_actions:
+
+            # remove the conflicting option
+            action.option_strings.remove(option_string)
+            self._option_string_actions.pop(option_string, None)
+
+            # if the option now has no option string, remove it from the
+            # container holding it
+            if not action.option_strings:
+                action.container._remove_action(action)
+
+
+class _ArgumentGroup(_ActionsContainer):
+
+    def __init__(self, container, title=None, description=None, **kwargs):
+        # add any missing keyword arguments by checking the container
+        update = kwargs.setdefault
+        update('conflict_handler', container.conflict_handler)
+        update('prefix_chars', container.prefix_chars)
+        update('argument_default', container.argument_default)
+        super_init = super(_ArgumentGroup, self).__init__
+        super_init(description=description, **kwargs)
+
+        # group attributes
+        self.title = title
+        self._group_actions = []
+
+        # share most attributes with the container
+        self._registries = container._registries
+        self._actions = container._actions
+        self._option_string_actions = container._option_string_actions
+        self._defaults = container._defaults
+        self._has_negative_number_optionals = \
+            container._has_negative_number_optionals
+
+    def _add_action(self, action):
+        action = super(_ArgumentGroup, self)._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        super(_ArgumentGroup, self)._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class _MutuallyExclusiveGroup(_ArgumentGroup):
+
+    def __init__(self, container, required=False):
+        super(_MutuallyExclusiveGroup, self).__init__(container)
+        self.required = required
+        self._container = container
+
+    def _add_action(self, action):
+        if action.required:
+            msg = _('mutually exclusive arguments must be optional')
+            raise ValueError(msg)
+        action = self._container._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        self._container._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class ArgumentParser(_AttributeHolder, _ActionsContainer):
+    """Object for parsing command line strings into Python objects.
+
+    Keyword Arguments:
+        - prog -- The name of the program (default: sys.argv[0])
+        - usage -- A usage message (default: auto-generated from arguments)
+        - description -- A description of what the program does
+        - epilog -- Text following the argument descriptions
+        - parents -- Parsers whose arguments should be copied into this one
+        - formatter_class -- HelpFormatter class for printing help messages
+        - prefix_chars -- Characters that prefix optional arguments
+        - fromfile_prefix_chars -- Characters that prefix files containing
+            additional arguments
+        - argument_default -- The default value for all arguments
+        - conflict_handler -- String indicating how to handle conflicts
+        - add_help -- Add a -h/-help option
+    """
+
+    def __init__(self,
+                 prog=None,
+                 usage=None,
+                 description=None,
+                 epilog=None,
+                 version=None,
+                 parents=[],
+                 formatter_class=HelpFormatter,
+                 prefix_chars='-',
+                 fromfile_prefix_chars=None,
+                 argument_default=None,
+                 conflict_handler='error',
+                 add_help=True):
+
+        if version is not None:
+            import warnings
+            warnings.warn(
+                """The "version" argument to ArgumentParser is deprecated. """
+                """Please use """
+                """"add_argument(..., action='version', version="N", ...)" """
+                """instead""", DeprecationWarning)
+
+        superinit = super(ArgumentParser, self).__init__
+        superinit(description=description,
+                  prefix_chars=prefix_chars,
+                  argument_default=argument_default,
+                  conflict_handler=conflict_handler)
+
+        # default setting for prog
+        if prog is None:
+            prog = _os.path.basename(_sys.argv[0])
+
+        self.prog = prog
+        self.usage = usage
+        self.epilog = epilog
+        self.version = version
+        self.formatter_class = formatter_class
+        self.fromfile_prefix_chars = fromfile_prefix_chars
+        self.add_help = add_help
+
+        add_group = self.add_argument_group
+        self._positionals = add_group(_('positional arguments'))
+        self._optionals = add_group(_('optional arguments'))
+        self._subparsers = None
+
+        # register types
+        def identity(string):
+            return string
+        self.register('type', None, identity)
+
+        # add help and version arguments if necessary
+        # (using explicit default to override global argument_default)
+        if '-' in prefix_chars:
+            default_prefix = '-'
+        else:
+            default_prefix = prefix_chars[0]
+        if self.add_help:
+            self.add_argument(
+                default_prefix+'h', default_prefix*2+'help',
+                action='help', default=SUPPRESS,
+                help=_('show this help message and exit'))
+        if self.version:
+            self.add_argument(
+                default_prefix+'v', default_prefix*2+'version',
+                action='version', default=SUPPRESS,
+                version=self.version,
+                help=_("show program's version number and exit"))
+
+        # add parent arguments and defaults
+        for parent in parents:
+            self._add_container_actions(parent)
+            try:
+                defaults = parent._defaults
+            except AttributeError:
+                pass
+            else:
+                self._defaults.update(defaults)
+
+    # =======================
+    # Pretty __repr__ methods
+    # =======================
+    def _get_kwargs(self):
+        names = [
+            'prog',
+            'usage',
+            'description',
+            'version',
+            'formatter_class',
+            'conflict_handler',
+            'add_help',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    # ==================================
+    # Optional/Positional adding methods
+    # ==================================
+    def add_subparsers(self, **kwargs):
+        if self._subparsers is not None:
+            self.error(_('cannot have multiple subparser arguments'))
+
+        # add the parser class to the arguments if it's not present
+        kwargs.setdefault('parser_class', type(self))
+
+        if 'title' in kwargs or 'description' in kwargs:
+            title = _(kwargs.pop('title', 'subcommands'))
+            description = _(kwargs.pop('description', None))
+            self._subparsers = self.add_argument_group(title, description)
+        else:
+            self._subparsers = self._positionals
+
+        # prog defaults to the usage message of this parser, skipping
+        # optional arguments and with no "usage:" prefix
+        if kwargs.get('prog') is None:
+            formatter = self._get_formatter()
+            positionals = self._get_positional_actions()
+            groups = self._mutually_exclusive_groups
+            formatter.add_usage(self.usage, positionals, groups, '')
+            kwargs['prog'] = formatter.format_help().strip()
+
+        # create the parsers action and add it to the positionals list
+        parsers_class = self._pop_action_class(kwargs, 'parsers')
+        action = parsers_class(option_strings=[], **kwargs)
+        self._subparsers._add_action(action)
+
+        # return the created parsers action
+        return action
+
+    def _add_action(self, action):
+        if action.option_strings:
+            self._optionals._add_action(action)
+        else:
+            self._positionals._add_action(action)
+        return action
+
+    def _get_optional_actions(self):
+        return [action
+                for action in self._actions
+                if action.option_strings]
+
+    def _get_positional_actions(self):
+        return [action
+                for action in self._actions
+                if not action.option_strings]
+
+    # =====================================
+    # Command line argument parsing methods
+    # =====================================
+    def parse_args(self, args=None, namespace=None):
+        args, argv = self.parse_known_args(args, namespace)
+        if argv:
+            msg = _('unrecognized arguments: %s')
+            self.error(msg % ' '.join(argv))
+        return args
+
+    def parse_known_args(self, args=None, namespace=None):
+        # args default to the system args
+        if args is None:
+            args = _sys.argv[1:]
+
+        # default Namespace built from parser defaults
+        if namespace is None:
+            namespace = Namespace()
+
+        # add any action defaults that aren't present
+        for action in self._actions:
+            if action.dest is not SUPPRESS:
+                if not hasattr(namespace, action.dest):
+                    if action.default is not SUPPRESS:
+                        setattr(namespace, action.dest, action.default)
+
+        # add any parser defaults that aren't present
+        for dest in self._defaults:
+            if not hasattr(namespace, dest):
+                setattr(namespace, dest, self._defaults[dest])
+
+        # parse the arguments and exit if there are any errors
+        try:
+            namespace, args = self._parse_known_args(args, namespace)
+            if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
+                args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
+                delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
+            return namespace, args
+        except ArgumentError:
+            err = _sys.exc_info()[1]
+            self.error(str(err))
+
+    def _parse_known_args(self, arg_strings, namespace):
+        # replace arg strings that are file references
+        if self.fromfile_prefix_chars is not None:
+            arg_strings = self._read_args_from_files(arg_strings)
+
+        # map all mutually exclusive arguments to the other arguments
+        # they can't occur with
+        action_conflicts = {}
+        for mutex_group in self._mutually_exclusive_groups:
+            group_actions = mutex_group._group_actions
+            for i, mutex_action in enumerate(mutex_group._group_actions):
+                conflicts = action_conflicts.setdefault(mutex_action, [])
+                conflicts.extend(group_actions[:i])
+                conflicts.extend(group_actions[i + 1:])
+
+        # find all option indices, and determine the arg_string_pattern
+        # which has an 'O' if there is an option at an index,
+        # an 'A' if there is an argument, or a '-' if there is a '--'
+        option_string_indices = {}
+        arg_string_pattern_parts = []
+        arg_strings_iter = iter(arg_strings)
+        for i, arg_string in enumerate(arg_strings_iter):
+
+            # all args after -- are non-options
+            if arg_string == '--':
+                arg_string_pattern_parts.append('-')
+                for arg_string in arg_strings_iter:
+                    arg_string_pattern_parts.append('A')
+
+            # otherwise, add the arg to the arg strings
+            # and note the index if it was an option
+            else:
+                option_tuple = self._parse_optional(arg_string)
+                if option_tuple is None:
+                    pattern = 'A'
+                else:
+                    option_string_indices[i] = option_tuple
+                    pattern = 'O'
+                arg_string_pattern_parts.append(pattern)
+
+        # join the pieces together to form the pattern
+        arg_strings_pattern = ''.join(arg_string_pattern_parts)
+
+        # converts arg strings to the appropriate and then takes the action
+        seen_actions = set()
+        seen_non_default_actions = set()
+
+        def take_action(action, argument_strings, option_string=None):
+            seen_actions.add(action)
+            argument_values = self._get_values(action, argument_strings)
+
+            # error if this argument is not allowed with other previously
+            # seen arguments, assuming that actions that use the default
+            # value don't really count as "present"
+            if argument_values is not action.default:
+                seen_non_default_actions.add(action)
+                for conflict_action in action_conflicts.get(action, []):
+                    if conflict_action in seen_non_default_actions:
+                        msg = _('not allowed with argument %s')
+                        action_name = _get_action_name(conflict_action)
+                        raise ArgumentError(action, msg % action_name)
+
+            # take the action if we didn't receive a SUPPRESS value
+            # (e.g. from a default)
+            if argument_values is not SUPPRESS:
+                action(self, namespace, argument_values, option_string)
+
+        # function to convert arg_strings into an optional action
+        def consume_optional(start_index):
+
+            # get the optional identified at this index
+            option_tuple = option_string_indices[start_index]
+            action, option_string, explicit_arg = option_tuple
+
+            # identify additional optionals in the same arg string
+            # (e.g. -xyz is the same as -x -y -z if no args are required)
+            match_argument = self._match_argument
+            action_tuples = []
+            while True:
+
+                # if we found no optional action, skip it
+                if action is None:
+                    extras.append(arg_strings[start_index])
+                    return start_index + 1
+
+                # if there is an explicit argument, try to match the
+                # optional's string arguments to only this
+                if explicit_arg is not None:
+                    arg_count = match_argument(action, 'A')
+
+                    # if the action is a single-dash option and takes no
+                    # arguments, try to parse more single-dash options out
+                    # of the tail of the option string
+                    chars = self.prefix_chars
+                    if arg_count == 0 and option_string[1] not in chars:
+                        action_tuples.append((action, [], option_string))
+                        char = option_string[0]
+                        option_string = char + explicit_arg[0]
+                        new_explicit_arg = explicit_arg[1:] or None
+                        optionals_map = self._option_string_actions
+                        if option_string in optionals_map:
+                            action = optionals_map[option_string]
+                            explicit_arg = new_explicit_arg
+                        else:
+                            msg = _('ignored explicit argument %r')
+                            raise ArgumentError(action, msg % explicit_arg)
+
+                    # if the action expect exactly one argument, we've
+                    # successfully matched the option; exit the loop
+                    elif arg_count == 1:
+                        stop = start_index + 1
+                        args = [explicit_arg]
+                        action_tuples.append((action, args, option_string))
+                        break
+
+                    # error if a double-dash option did not use the
+                    # explicit argument
+                    else:
+                        msg = _('ignored explicit argument %r')
+                        raise ArgumentError(action, msg % explicit_arg)
+
+                # if there is no explicit argument, try to match the
+                # optional's string arguments with the following strings
+                # if successful, exit the loop
+                else:
+                    start = start_index + 1
+                    selected_patterns = arg_strings_pattern[start:]
+                    arg_count = match_argument(action, selected_patterns)
+                    stop = start + arg_count
+                    args = arg_strings[start:stop]
+                    action_tuples.append((action, args, option_string))
+                    break
+
+            # add the Optional to the list and return the index at which
+            # the Optional's string args stopped
+            assert action_tuples
+            for action, args, option_string in action_tuples:
+                take_action(action, args, option_string)
+            return stop
+
+        # the list of Positionals left to be parsed; this is modified
+        # by consume_positionals()
+        positionals = self._get_positional_actions()
+
+        # function to convert arg_strings into positional actions
+        def consume_positionals(start_index):
+            # match as many Positionals as possible
+            match_partial = self._match_arguments_partial
+            selected_pattern = arg_strings_pattern[start_index:]
+            arg_counts = match_partial(positionals, selected_pattern)
+
+            # slice off the appropriate arg strings for each Positional
+            # and add the Positional and its args to the list
+            for action, arg_count in zip(positionals, arg_counts):
+                args = arg_strings[start_index: start_index + arg_count]
+                start_index += arg_count
+                take_action(action, args)
+
+            # slice off the Positionals that we just parsed and return the
+            # index at which the Positionals' string args stopped
+            positionals[:] = positionals[len(arg_counts):]
+            return start_index
+
+        # consume Positionals and Optionals alternately, until we have
+        # passed the last option string
+        extras = []
+        start_index = 0
+        if option_string_indices:
+            max_option_string_index = max(option_string_indices)
+        else:
+            max_option_string_index = -1
+        while start_index <= max_option_string_index:
+
+            # consume any Positionals preceding the next option
+            next_option_string_index = min([
+                index
+                for index in option_string_indices
+                if index >= start_index])
+            if start_index != next_option_string_index:
+                positionals_end_index = consume_positionals(start_index)
+
+                # only try to parse the next optional if we didn't consume
+                # the option string during the positionals parsing
+                if positionals_end_index > start_index:
+                    start_index = positionals_end_index
+                    continue
+                else:
+                    start_index = positionals_end_index
+
+            # if we consumed all the positionals we could and we're not
+            # at the index of an option string, there were extra arguments
+            if start_index not in option_string_indices:
+                strings = arg_strings[start_index:next_option_string_index]
+                extras.extend(strings)
+                start_index = next_option_string_index
+
+            # consume the next optional and any arguments for it
+            start_index = consume_optional(start_index)
+
+        # consume any positionals following the last Optional
+        stop_index = consume_positionals(start_index)
+
+        # if we didn't consume all the argument strings, there were extras
+        extras.extend(arg_strings[stop_index:])
+
+        # if we didn't use all the Positional objects, there were too few
+        # arg strings supplied.
+        if positionals:
+            self.error(_('too few arguments'))
+
+        # make sure all required actions were present, and convert defaults.
+        for action in self._actions:
+            if action not in seen_actions:
+                if action.required:
+                    name = _get_action_name(action)
+                    self.error(_('argument %s is required') % name)
+                else:
+                    # Convert action default now instead of doing it before
+                    # parsing arguments to avoid calling convert functions
+                    # twice (which may fail) if the argument was given, but
+                    # only if it was defined already in the namespace
+                    if (action.default is not None and
+                            isinstance(action.default, basestring) and
+                            hasattr(namespace, action.dest) and
+                            action.default is getattr(namespace, action.dest)):
+                        setattr(namespace, action.dest,
+                                self._get_value(action, action.default))
+
+        # make sure all required groups had one option present
+        for group in self._mutually_exclusive_groups:
+            if group.required:
+                for action in group._group_actions:
+                    if action in seen_non_default_actions:
+                        break
+
+                # if no actions were used, report the error
+                else:
+                    names = [_get_action_name(action)
+                             for action in group._group_actions
+                             if action.help is not SUPPRESS]
+                    msg = _('one of the arguments %s is required')
+                    self.error(msg % ' '.join(names))
+
+        # return the updated namespace and the extra arguments
+        return namespace, extras
+
+    def _read_args_from_files(self, arg_strings):
+        # expand arguments referencing files
+        new_arg_strings = []
+        for arg_string in arg_strings:
+
+            # for regular arguments, just add them back into the list
+            if arg_string[0] not in self.fromfile_prefix_chars:
+                new_arg_strings.append(arg_string)
+
+            # replace arguments referencing files with the file content
+            else:
+                try:
+                    args_file = open(arg_string[1:])
+                    try:
+                        arg_strings = []
+                        for arg_line in args_file.read().splitlines():
+                            for arg in self.convert_arg_line_to_args(arg_line):
+                                arg_strings.append(arg)
+                        arg_strings = self._read_args_from_files(arg_strings)
+                        new_arg_strings.extend(arg_strings)
+                    finally:
+                        args_file.close()
+                except IOError:
+                    err = _sys.exc_info()[1]
+                    self.error(str(err))
+
+        # return the modified argument list
+        return new_arg_strings
+
+    def convert_arg_line_to_args(self, arg_line):
+        return [arg_line]
+
+    def _match_argument(self, action, arg_strings_pattern):
+        # match the pattern for this action to the arg strings
+        nargs_pattern = self._get_nargs_pattern(action)
+        match = _re.match(nargs_pattern, arg_strings_pattern)
+
+        # raise an exception if we weren't able to find a match
+        if match is None:
+            nargs_errors = {
+                None: _('expected one argument'),
+                OPTIONAL: _('expected at most one argument'),
+                ONE_OR_MORE: _('expected at least one argument'),
+            }
+            default = _('expected %s argument(s)') % action.nargs
+            msg = nargs_errors.get(action.nargs, default)
+            raise ArgumentError(action, msg)
+
+        # return the number of arguments matched
+        return len(match.group(1))
+
+    def _match_arguments_partial(self, actions, arg_strings_pattern):
+        # progressively shorten the actions list by slicing off the
+        # final actions until we find a match
+        result = []
+        for i in range(len(actions), 0, -1):
+            actions_slice = actions[:i]
+            pattern = ''.join([self._get_nargs_pattern(action)
+                               for action in actions_slice])
+            match = _re.match(pattern, arg_strings_pattern)
+            if match is not None:
+                result.extend([len(string) for string in match.groups()])
+                break
+
+        # return the list of arg string counts
+        return result
+
+    def _parse_optional(self, arg_string):
+        # if it's an empty string, it was meant to be a positional
+        if not arg_string:
+            return None
+
+        # if it doesn't start with a prefix, it was meant to be positional
+        if not arg_string[0] in self.prefix_chars:
+            return None
+
+        # if the option string is present in the parser, return the action
+        if arg_string in self._option_string_actions:
+            action = self._option_string_actions[arg_string]
+            return action, arg_string, None
+
+        # if it's just a single character, it was meant to be positional
+        if len(arg_string) == 1:
+            return None
+
+        # if the option string before the "=" is present, return the action
+        if '=' in arg_string:
+            option_string, explicit_arg = arg_string.split('=', 1)
+            if option_string in self._option_string_actions:
+                action = self._option_string_actions[option_string]
+                return action, option_string, explicit_arg
+
+        # search through all possible prefixes of the option string
+        # and all actions in the parser for possible interpretations
+        option_tuples = self._get_option_tuples(arg_string)
+
+        # if multiple actions match, the option string was ambiguous
+        if len(option_tuples) > 1:
+            options = ', '.join([option_string
+                for action, option_string, explicit_arg in option_tuples])
+            tup = arg_string, options
+            self.error(_('ambiguous option: %s could match %s') % tup)
+
+        # if exactly one action matched, this segmentation is good,
+        # so return the parsed action
+        elif len(option_tuples) == 1:
+            option_tuple, = option_tuples
+            return option_tuple
+
+        # if it was not found as an option, but it looks like a negative
+        # number, it was meant to be positional
+        # unless there are negative-number-like options
+        if self._negative_number_matcher.match(arg_string):
+            if not self._has_negative_number_optionals:
+                return None
+
+        # if it contains a space, it was meant to be a positional
+        if ' ' in arg_string:
+            return None
+
+        # it was meant to be an optional but there is no such option
+        # in this parser (though it might be a valid option in a subparser)
+        return None, arg_string, None
+
+    def _get_option_tuples(self, option_string):
+        result = []
+
+        # option strings starting with two prefix characters are only
+        # split at the '='
+        chars = self.prefix_chars
+        if option_string[0] in chars and option_string[1] in chars:
+            if '=' in option_string:
+                option_prefix, explicit_arg = option_string.split('=', 1)
+            else:
+                option_prefix = option_string
+                explicit_arg = None
+            for option_string in self._option_string_actions:
+                if option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # single character options can be concatenated with their arguments
+        # but multiple character options always have to have their argument
+        # separate
+        elif option_string[0] in chars and option_string[1] not in chars:
+            option_prefix = option_string
+            explicit_arg = None
+            short_option_prefix = option_string[:2]
+            short_explicit_arg = option_string[2:]
+
+            for option_string in self._option_string_actions:
+                if option_string == short_option_prefix:
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, short_explicit_arg
+                    result.append(tup)
+                elif option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # shouldn't ever get here
+        else:
+            self.error(_('unexpected option string: %s') % option_string)
+
+        # return the collected option tuples
+        return result
+
+    def _get_nargs_pattern(self, action):
+        # in all examples below, we have to allow for '--' args
+        # which are represented as '-' in the pattern
+        nargs = action.nargs
+
+        # the default (None) is assumed to be a single argument
+        if nargs is None:
+            nargs_pattern = '(-*A-*)'
+
+        # allow zero or one arguments
+        elif nargs == OPTIONAL:
+            nargs_pattern = '(-*A?-*)'
+
+        # allow zero or more arguments
+        elif nargs == ZERO_OR_MORE:
+            nargs_pattern = '(-*[A-]*)'
+
+        # allow one or more arguments
+        elif nargs == ONE_OR_MORE:
+            nargs_pattern = '(-*A[A-]*)'
+
+        # allow any number of options or arguments
+        elif nargs == REMAINDER:
+            nargs_pattern = '([-AO]*)'
+
+        # allow one argument followed by any number of options or arguments
+        elif nargs == PARSER:
+            nargs_pattern = '(-*A[-AO]*)'
+
+        # all others should be integers
+        else:
+            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
+
+        # if this is an optional action, -- is not allowed
+        if action.option_strings:
+            nargs_pattern = nargs_pattern.replace('-*', '')
+            nargs_pattern = nargs_pattern.replace('-', '')
+
+        # return the pattern
+        return nargs_pattern
+
+    # ========================
+    # Value conversion methods
+    # ========================
+    def _get_values(self, action, arg_strings):
+        # for everything but PARSER args, strip out '--'
+        if action.nargs not in [PARSER, REMAINDER]:
+            arg_strings = [s for s in arg_strings if s != '--']
+
+        # optional argument produces a default when not present
+        if not arg_strings and action.nargs == OPTIONAL:
+            if action.option_strings:
+                value = action.const
+            else:
+                value = action.default
+            if isinstance(value, basestring):
+                value = self._get_value(action, value)
+                self._check_value(action, value)
+
+        # when nargs='*' on a positional, if there were no command-line
+        # args, use the default if it is anything other than None
+        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
+              not action.option_strings):
+            if action.default is not None:
+                value = action.default
+            else:
+                value = arg_strings
+            self._check_value(action, value)
+
+        # single argument or optional argument produces a single value
+        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
+            arg_string, = arg_strings
+            value = self._get_value(action, arg_string)
+            self._check_value(action, value)
+
+        # REMAINDER arguments convert all values, checking none
+        elif action.nargs == REMAINDER:
+            value = [self._get_value(action, v) for v in arg_strings]
+
+        # PARSER arguments convert all values, but check only the first
+        elif action.nargs == PARSER:
+            value = [self._get_value(action, v) for v in arg_strings]
+            self._check_value(action, value[0])
+
+        # all other types of nargs produce a list
+        else:
+            value = [self._get_value(action, v) for v in arg_strings]
+            for v in value:
+                self._check_value(action, v)
+
+        # return the converted value
+        return value
+
+    def _get_value(self, action, arg_string):
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            msg = _('%r is not callable')
+            raise ArgumentError(action, msg % type_func)
+
+        # convert the value to the appropriate type
+        try:
+            result = type_func(arg_string)
+
+        # ArgumentTypeErrors indicate errors
+        except ArgumentTypeError:
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = str(_sys.exc_info()[1])
+            raise ArgumentError(action, msg)
+
+        # TypeErrors or ValueErrors also indicate errors
+        except (TypeError, ValueError):
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = _('invalid %s value: %r')
+            raise ArgumentError(action, msg % (name, arg_string))
+
+        # return the converted value
+        return result
+
+    def _check_value(self, action, value):
+        # converted value must be one of the choices (if specified)
+        if action.choices is not None and value not in action.choices:
+            tup = value, ', '.join(map(repr, action.choices))
+            msg = _('invalid choice: %r (choose from %s)') % tup
+            raise ArgumentError(action, msg)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_usage(self):
+        formatter = self._get_formatter()
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+        return formatter.format_help()
+
+    def format_help(self):
+        formatter = self._get_formatter()
+
+        # usage
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+
+        # description
+        formatter.add_text(self.description)
+
+        # positionals, optionals and user-defined groups
+        for action_group in self._action_groups:
+            formatter.start_section(action_group.title)
+            formatter.add_text(action_group.description)
+            formatter.add_arguments(action_group._group_actions)
+            formatter.end_section()
+
+        # epilog
+        formatter.add_text(self.epilog)
+
+        # determine help from format above
+        return formatter.format_help()
+
+    def format_version(self):
+        import warnings
+        warnings.warn(
+            'The format_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        formatter = self._get_formatter()
+        formatter.add_text(self.version)
+        return formatter.format_help()
+
+    def _get_formatter(self):
+        return self.formatter_class(prog=self.prog)
+
+    # =====================
+    # Help-printing methods
+    # =====================
+    def print_usage(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_usage(), file)
+
+    def print_help(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_help(), file)
+
+    def print_version(self, file=None):
+        import warnings
+        warnings.warn(
+            'The print_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        self._print_message(self.format_version(), file)
+
+    def _print_message(self, message, file=None):
+        if message:
+            if file is None:
+                file = _sys.stderr
+            file.write(message)
+
+    # ===============
+    # Exiting methods
+    # ===============
+    def exit(self, status=0, message=None):
+        if message:
+            self._print_message(message, _sys.stderr)
+        _sys.exit(status)
+
+    def error(self, message):
+        """error(message: string)
+
+        Prints a usage message incorporating the message to stderr and
+        exits.
+
+        If you override this in a subclass, it should not return -- it
+        should either exit or raise an exception.
+        """
+        self.print_usage(_sys.stderr)
+        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
-- 
2.13.5

Add the scripts/ directory to sys.path so Python 2.6 will be able to
import argparse.

Cc: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: John Snow <jsnow@redhat.com>
Acked-by: Fam Zheng <famz@redhat.com>
Message-id: 20170825155732.15665-4-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/migration/guestperf/shell.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/migration/guestperf/shell.py b/tests/migration/guestperf/shell.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/migration/guestperf/shell.py
+++ b/tests/migration/guestperf/shell.py
@@ -XXX,XX +XXX,XX @@
 #
 
 
-import argparse
-import fnmatch
 import os
 import os.path
-import platform
 import sys
+sys.path.append(os.path.join(os.path.dirname(__file__),
+                             '..', '..', '..', 'scripts'))
+import argparse
+import fnmatch
+import platform
 
 from guestperf.hardware import Hardware
 from guestperf.engine import Engine
-- 
2.13.5

From: Fred Rolland <rollandf@gmail.com>

Update doc with the usage of UUID for initiator name.

Related-To: https://bugzilla.redhat.com/1006468
Signed-off-by: Fred Rolland <frolland@redhat.com>
Message-id: 20170823084830.30500-1-frolland@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qemu-doc.texi | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ in a configuration file provided via '-readconfig' or directly on the
 command line.
 
 If the initiator-name is not specified qemu will use a default name
-of 'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+of 'iqn.2008-11.org.linux-kvm[:<uuid>'] where <uuid> is the UUID of the
+virtual machine. If the UUID is not specified qemu will use
+'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
 virtual machine.
 
-
 @example
 Setting a specific initiator name to use when logging in to the target
 -iscsi initiator-name=iqn.qemu.test:my-initiator
-- 
2.13.5

Most qcow2 files are uncompressed so it is wasteful to allocate (32 + 1)
* cluster_size + 512 bytes upfront.  Allocate s->cluster_cache and
s->cluster_data when the first read operation is performance on a
compressed cluster.

The buffers are freed in .bdrv_close().  .bdrv_open() no longer has any
code paths that can allocate these buffers, so remove the free functions
in the error code path.

This patch can result in significant memory savings when many qcow2
disks are attached or backing file chains are long:

Before 12.81% (1,023,193,088B)
After   5.36% (393,893,888B)

Reported-by: Alexey Kardashevskiy <aik@ozlabs.ru>
Tested-by: Alexey Kardashevskiy <aik@ozlabs.ru>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20170821135530.32344-1-stefanha@redhat.com
Cc: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow2-cluster.c | 17 +++++++++++++++++
 block/qcow2.c         | 12 ------------
 2 files changed, 17 insertions(+), 12 deletions(-)

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 @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
         nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
         sector_offset = coffset & 511;
         csize = nb_csectors * 512 - sector_offset;
+
+        /* Allocate buffers on first decompress operation, most images are
+         * uncompressed and the memory overhead can be avoided.  The buffers
+         * are freed in .bdrv_close().
+         */
+        if (!s->cluster_data) {
+            /* one more sector for decompressed data alignment */
+            s->cluster_data = qemu_try_blockalign(bs->file->bs,
+                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size + 512);
+            if (!s->cluster_data) {
+                return -ENOMEM;
+            }
+        }
+        if (!s->cluster_cache) {
+            s->cluster_cache = g_malloc(s->cluster_size);
+        }
+
         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
         ret = bdrv_read(bs->file, coffset >> 9, s->cluster_data,
                         nb_csectors);
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    s->cluster_cache = g_malloc(s->cluster_size);
-    /* one more sector for decompressed data alignment */
-    s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
-                                                    * s->cluster_size + 512);
-    if (s->cluster_data == NULL) {
-        error_setg(errp, "Could not allocate temporary cluster buffer");
-        ret = -ENOMEM;
-        goto fail;
-    }
-
     s->cluster_cache_offset = -1;
     s->flags = flags;
 
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
     if (s->refcount_block_cache) {
         qcow2_cache_destroy(bs, s->refcount_block_cache);
     }
-    g_free(s->cluster_cache);
-    qemu_vfree(s->cluster_data);
     qcrypto_block_free(s->crypto);
     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
     return ret;
-- 
2.13.5

The following changes since commit 56f9e46b841c7be478ca038d8d4085d776ab4b0d:

Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2017-02-20' into staging (2017-02-20 17:42:47 +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 a7b91d35bab97a2d3e779d0c64c9b837b52a6cf7:

coroutine-lock: make CoRwlock thread-safe and fair (2017-02-21 11:39:40 +0000)

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

v2:
 * Rebased to resolve scsi conflicts

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

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 |  7 +++++++
 util/aio-posix.c      |  7 -------
 util/aio-win32.c      |  6 ------
 11 files changed, 68 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 @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
     MultiReqBuffer mrb = {};
     bool progress = false;
 
+    aio_context_acquire(blk_get_aio_context(s->blk));
     blk_io_plug(s->blk);
 
     do {
@@ -XXX,XX +XXX,XX @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
     }
 
     blk_io_unplug(s->blk);
+    aio_context_release(blk_get_aio_context(s->blk));
     return progress;
 }
 
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 @@ bool virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq)
     VirtIOSCSIReq *req;
     bool progress = false;
 
+    virtio_scsi_acquire(s);
     while ((req = virtio_scsi_pop_req(s, vq))) {
         progress = true;
         virtio_scsi_handle_ctrl_req(s, req);
     }
+    virtio_scsi_release(s);
     return progress;
 }
 
@@ -XXX,XX +XXX,XX @@ bool 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 @@ bool 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);
     return progress;
 }
 
@@ -XXX,XX +XXX,XX @@ out:
 
 bool 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);
         return true;
     }
+    virtio_scsi_release(s);
     return false;
 }
 
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