Series comparison

-[Qemu-devel] [PULL for-2.10 00/15] Block patches
+[PULL 00/18] Block patches
-The following changes since commit 248b23735645f7cbb503d9be6f5bf825f2a603ab:
+The following changes since commit 8e6c70b9d4a1b1f3011805947925cfdb31642f7f:
-  Update version for v2.10.0-rc4 release (2017-08-24 17:34:26 +0100)
+  Merge tag 'kraxel-20220614-pull-request' of git://git.kraxel.org/qemu into staging (2022-06-14 06:21:46 -0700)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 3e4c705212abfe8c9882a00beb2d1466a8a53cec:
+for you to fetch changes up to 99b969fbe105117f5af6060d3afef40ca39cc9c1:
-  qcow2: allocate cluster_cache/cluster_data on demand (2017-08-30 18:02:10 +0100)
+  linux-aio: explain why max batch is checked in laio_io_unplug() (2022-06-15 16:43:42 +0100)
 ----------------------------------------------------------------
 Pull request
 This pull request includes an important aio=native I/O stall fix, the
 experimental vifo-user server, the io_uring_register_ring_fd() optimization for
 aio=io_uring, and an update to Vladimir Sementsov-Ogievskiy's maintainership
 details.
 ----------------------------------------------------------------
-----------------------------------------------------------------
+Jagannathan Raman (14):
   qdev: unplug blocker for devices
   remote/machine: add HotplugHandler for remote machine
   remote/machine: add vfio-user property
   vfio-user: build library
   vfio-user: define vfio-user-server object
   vfio-user: instantiate vfio-user context
   vfio-user: find and init PCI device
   vfio-user: run vfio-user context
   vfio-user: handle PCI config space accesses
   vfio-user: IOMMU support for remote device
   vfio-user: handle DMA mappings
   vfio-user: handle PCI BAR accesses
   vfio-user: handle device interrupts
   vfio-user: handle reset of remote device
-Alberto Garcia (8):
+Sam Li (1):
-  throttle: Fix wrong variable name in the header documentation
+  Use io_uring_register_ring_fd() to skip fd operations
   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):
+Stefan Hajnoczi (2):
-  nvme: Fix get/set number of queues feature, again
+  linux-aio: fix unbalanced plugged counter in laio_io_unplug()
   linux-aio: explain why max batch is checked in laio_io_unplug()
-Eduardo Habkost (1):
+Vladimir Sementsov-Ogievskiy (1):
-  oslib-posix: Print errors before aborting on qemu_alloc_stack()
+  MAINTAINERS: update Vladimir's address and repositories
-Fred Rolland (1):
+ MAINTAINERS                             |  27 +-
-  qemu-doc: Add UUID support in initiator name
+ meson_options.txt                       |   2 +
+ qapi/misc.json                          |  31 +
-Stefan Hajnoczi (4):
+ qapi/qom.json                           |  20 +-
-  scripts: add argparse module for Python 2.6 compatibility
+ configure                               |  17 +
-  docker.py: Python 2.6 argparse compatibility
+ meson.build                             |  24 +-
-  tests: migration/guestperf Python 2.6 argparse compatibility
+ include/exec/memory.h                   |   3 +
-  qcow2: allocate cluster_cache/cluster_data on demand
+ include/hw/pci/msi.h                    |   1 +
+ include/hw/pci/msix.h                   |   1 +
- include/qemu/throttle.h            |    8 +-
+ include/hw/pci/pci.h                    |  13 +
- block/qcow.c                       |   12 +-
+ include/hw/qdev-core.h                  |  29 +
- block/qcow2-cluster.c              |   17 +
+ include/hw/remote/iommu.h               |  40 +
- block/qcow2.c                      |   20 +-
+ include/hw/remote/machine.h             |   4 +
- dump.c                             |    4 +-
+ include/hw/remote/vfio-user-obj.h       |   6 +
- hw/block/nvme.c                    |    4 +-
+ block/io_uring.c                        |  12 +-
- tests/test-throttle.c              |   80 +-
+ block/linux-aio.c                       |  10 +-
- util/oslib-posix.c                 |    2 +
+ hw/core/qdev.c                          |  24 +
- util/throttle.c                    |   86 +-
+ hw/pci/msi.c                            |  49 +-
- COPYING.PYTHON                     |  270 ++++
+ hw/pci/msix.c                           |  35 +-
- qemu-doc.texi                      |    5 +-
+ hw/pci/pci.c                            |  13 +
- scripts/argparse.py                | 2406 ++++++++++++++++++++++++++++++++++++
+ hw/remote/iommu.c                       | 131 ++++
- tests/docker/docker.py             |    4 +-
+ hw/remote/machine.c                     |  88 ++-
- tests/migration/guestperf/shell.py |    8 +-
+ hw/remote/vfio-user-obj.c               | 958 ++++++++++++++++++++++++
-files changed, 2831 insertions(+), 95 deletions(-)
+ softmmu/physmem.c                       |   4 +-
- create mode 100644 COPYING.PYTHON
+ softmmu/qdev-monitor.c                  |   4 +
- create mode 100644 scripts/argparse.py
+ stubs/vfio-user-obj.c                   |   6 +
  tests/qtest/fuzz/generic_fuzz.c         |   9 +-
  .gitlab-ci.d/buildtest.yml              |   1 +
  .gitmodules                             |   3 +
  Kconfig.host                            |   4 +
  hw/remote/Kconfig                       |   4 +
  hw/remote/meson.build                   |   4 +
  hw/remote/trace-events                  |  11 +
  scripts/meson-buildoptions.sh           |   4 +
  stubs/meson.build                       |   1 +
  subprojects/libvfio-user                |   1 +
  tests/docker/dockerfiles/centos8.docker |   2 +
 files changed, 1565 insertions(+), 31 deletions(-)
  create mode 100644 include/hw/remote/iommu.h
  create mode 100644 include/hw/remote/vfio-user-obj.h
  create mode 100644 hw/remote/iommu.c
  create mode 100644 hw/remote/vfio-user-obj.c
  create mode 100644 stubs/vfio-user-obj.c
  create mode 160000 subprojects/libvfio-user
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 14/15] qemu-doc: Add UUID support in initiator name
+[PULL 01/18] MAINTAINERS: update Vladimir's address and repositories
-From: Fred Rolland <rollandf@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
-Update doc with the usage of UUID for initiator name.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+Message-id: 20220526115432.138384-1-vsementsov@yandex-team.ru
 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 +++--
+ MAINTAINERS | 22 ++++++++++++----------
-file changed, 3 insertions(+), 2 deletions(-)
+file changed, 12 insertions(+), 10 deletions(-)
-diff --git a/qemu-doc.texi b/qemu-doc.texi
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-doc.texi
+--- a/MAINTAINERS
-+++ b/qemu-doc.texi
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ in a configuration file provided via '-readconfig' or directly on the
+@@ -XXX,XX +XXX,XX @@ F: scsi/*
- command line.
+ Block Jobs
- If the initiator-name is not specified qemu will use a default name
+ M: John Snow <jsnow@redhat.com>
--of 'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+-M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
-+of 'iqn.2008-11.org.linux-kvm[:<uuid>'] where <uuid> is the UUID of the
++M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
-+virtual machine. If the UUID is not specified qemu will use
+ L: qemu-block@nongnu.org
-+'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+ S: Supported
- virtual machine.
+ F: blockjob.c
+@@ -XXX,XX +XXX,XX @@ F: block/aio_task.c
--
+ F: util/qemu-co-shared-resource.c
- @example
+ F: include/qemu/co-shared-resource.h
- Setting a specific initiator name to use when logging in to the target
+ T: git https://gitlab.com/jsnow/qemu.git jobs
- -iscsi initiator-name=iqn.qemu.test:my-initiator
+-T: git https://src.openvz.org/scm/~vsementsov/qemu.git jobs
 +T: git https://gitlab.com/vsementsov/qemu.git block
  Block QAPI, monitor, command line
  M: Markus Armbruster <armbru@redhat.com>
@@ -XXX,XX +XXX,XX @@ F: include/hw/cxl/
  Dirty Bitmaps
  M: Eric Blake <eblake@redhat.com>
 -M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
 +M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
  R: John Snow <jsnow@redhat.com>
  L: qemu-block@nongnu.org
  S: Supported
@@ -XXX,XX +XXX,XX @@ F: util/hbitmap.c
  F: tests/unit/test-hbitmap.c
  F: docs/interop/bitmaps.rst
  T: git https://repo.or.cz/qemu/ericb.git bitmaps
 +T: git https://gitlab.com/vsementsov/qemu.git block
  Character device backends
  M: Marc-André Lureau <marcandre.lureau@redhat.com>
@@ -XXX,XX +XXX,XX @@ F: scripts/*.py
  F: tests/*.py
  Benchmark util
 -M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
 +M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
  S: Maintained
  F: scripts/simplebench/
 -T: git https://src.openvz.org/scm/~vsementsov/qemu.git simplebench
 +T: git https://gitlab.com/vsementsov/qemu.git simplebench
  Transactions helper
 -M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
 +M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
  S: Maintained
  F: include/qemu/transactions.h
  F: util/transactions.c
 +T: git https://gitlab.com/vsementsov/qemu.git block
  QAPI
  M: Markus Armbruster <armbru@redhat.com>
@@ -XXX,XX +XXX,XX @@ F: block/iscsi-opts.c
  Network Block Device (NBD)
  M: Eric Blake <eblake@redhat.com>
 -M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
 +M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
  L: qemu-block@nongnu.org
  S: Maintained
  F: block/nbd*
@@ -XXX,XX +XXX,XX @@ F: docs/interop/nbd.txt
  F: docs/tools/qemu-nbd.rst
  F: tests/qemu-iotests/tests/*nbd*
  T: git https://repo.or.cz/qemu/ericb.git nbd
 -T: git https://src.openvz.org/scm/~vsementsov/qemu.git nbd
 +T: git https://gitlab.com/vsementsov/qemu.git block
  NFS
  M: Peter Lieven <pl@kamp.de>
@@ -XXX,XX +XXX,XX @@ F: block/dmg.c
  parallels
  M: Stefan Hajnoczi <stefanha@redhat.com>
  M: Denis V. Lunev <den@openvz.org>
 -M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
 +M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
  L: qemu-block@nongnu.org
  S: Supported
  F: block/parallels.c
  F: block/parallels-ext.c
  F: docs/interop/parallels.txt
 -T: git https://src.openvz.org/scm/~vsementsov/qemu.git parallels
 +T: git https://gitlab.com/vsementsov/qemu.git block
  qed
  M: Stefan Hajnoczi <stefanha@redhat.com>
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 09/15] oslib-posix: Print errors before aborting on qemu_alloc_stack()
+[PULL 02/18] Use io_uring_register_ring_fd() to skip fd operations
-From: Eduardo Habkost <ehabkost@redhat.com>
+From: Sam Li <faithilikerun@gmail.com>
-If QEMU is running on a system that's out of memory and mmap()
+Linux recently added a new io_uring(7) optimization API that QEMU
-fails, QEMU aborts with no error message at all, making it hard
+doesn't take advantage of yet. The liburing library that QEMU uses
-to debug the reason for the failure.
+has added a corresponding new API calling io_uring_register_ring_fd().
 When this API is called after creating the ring, the io_uring_submit()
 library function passes a flag to the io_uring_enter(2) syscall
 allowing it to skip the ring file descriptor fdget()/fdput()
 operations. This saves some CPU cycles.
-Add perror() calls that will print error information before
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
-aborting.
+Message-id: 20220531105011.111082-1-faithilikerun@gmail.com
 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 ++
+ meson.build      |  1 +
-file changed, 2 insertions(+)
+ block/io_uring.c | 12 +++++++++++-
 files changed, 12 insertions(+), 1 deletion(-)
-diff --git a/util/oslib-posix.c b/util/oslib-posix.c
+diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
---- a/util/oslib-posix.c
+--- a/meson.build
-+++ b/util/oslib-posix.c
++++ b/meson.build
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_LIBNFS', libnfs.found())
-     ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
+ config_host_data.set('CONFIG_LIBSSH', libssh.found())
-                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
-     if (ptr == MAP_FAILED) {
+ config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
-+        perror("failed to allocate memory for stack");
++config_host_data.set('CONFIG_LIBURING_REGISTER_RING_FD', cc.has_function('io_uring_register_ring_fd', prefix: '#include <liburing.h>', dependencies:linux_io_uring))
-         abort();
+ config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
  config_host_data.set('CONFIG_NUMA', numa.found())
  config_host_data.set('CONFIG_OPENGL', opengl.found())
 diff --git a/block/io_uring.c b/block/io_uring.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io_uring.c
 +++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/error.h"
  #include "trace.h"
 +
  /* io_uring ring size */
  #define MAX_ENTRIES 128
@@ -XXX,XX +XXX,XX @@ LuringState *luring_init(Error **errp)
      }
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+     ioq_init(&s->io_q);
-     guardpage = ptr;
++#ifdef CONFIG_LIBURING_REGISTER_RING_FD
- #endif
++    if (io_uring_register_ring_fd(&s->ring) < 0) {
-     if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
++        /*
-+        perror("failed to set up stack guard page");
++         * Only warn about this error: we will fallback to the non-optimized
-         abort();
++         * io_uring operations.
-     }
++         */
++        warn_report("failed to register linux io_uring ring file descriptor");
 +    }
 +#endif
 +
      return s;
 -
  }
  void luring_cleanup(LuringState *s)
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 10/15] misc: Remove unused Error variables
+[PULL 03/18] qdev: unplug blocker for devices
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-There's a few cases which we're passing an Error pointer to a function
+Add blocker to prevent hot-unplug of devices
 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>
+TYPE_VFIO_USER_SERVER, which is introduced shortly, attaches itself to a
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+PCIDevice on which it depends. If the attached PCIDevice gets removed
-Reviewed-by: Eric Blake <eblake@redhat.com>
+while the server in use, it could cause it crash. To prevent this,
-Message-id: 20170829120836.16091-1-berto@igalia.com
+TYPE_VFIO_USER_SERVER adds an unplug blocker for the PCIDevice.
 Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
 Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
 Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: c41ef80b7cc063314d629737bed2159e5713f2e0.1655151679.git.jag.raman@oracle.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/qcow.c  | 12 +++---------
+ include/hw/qdev-core.h | 29 +++++++++++++++++++++++++++++
- block/qcow2.c |  8 ++------
+ hw/core/qdev.c         | 24 ++++++++++++++++++++++++
- dump.c        |  4 +---
+ softmmu/qdev-monitor.c |  4 ++++
-files changed, 6 insertions(+), 18 deletions(-)
+files changed, 57 insertions(+)
-diff --git a/block/qcow.c b/block/qcow.c
+diff --git a/include/hw/qdev-core.h b/include/hw/qdev-core.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow.c
+--- a/include/hw/qdev-core.h
-+++ b/block/qcow.c
++++ b/include/hw/qdev-core.h
-@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ struct DeviceState {
-                     start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
+     int instance_id_alias;
-                     for(i = 0; i < s->cluster_sectors; i++) {
+     int alias_required_for_version;
-                         if (i < n_start || i >= n_end) {
+     ResettableState reset;
--                            Error *err = NULL;
++    GSList *unplug_blockers;
-                             memset(s->cluster_data, 0x00, 512);
+ };
-                             if (qcrypto_block_encrypt(s->crypto, start_sect + i,
-                                                       s->cluster_data,
+ struct DeviceListener {
-                                                       BDRV_SECTOR_SIZE,
+@@ -XXX,XX +XXX,XX @@ void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
--                                                      &err) < 0) {
+ void qdev_machine_creation_done(void);
--                                error_free(err);
+ bool qdev_machine_modified(void);
-+                                                      NULL) < 0) {
-                                 errno = EIO;
++/**
-                                 return -1;
++ * qdev_add_unplug_blocker: Add an unplug blocker to a device
-                             }
++ *
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
++ * @dev: Device to be blocked from unplug
-     QEMUIOVector hd_qiov;
++ * @reason: Reason for blocking
-     uint8_t *buf;
++ */
-     void *orig_buf;
++void qdev_add_unplug_blocker(DeviceState *dev, Error *reason);
--    Error *err = NULL;
++
++/**
-     if (qiov->niov > 1) {
++ * qdev_del_unplug_blocker: Remove an unplug blocker from a device
-         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,
++ * @dev: Device to be unblocked
-             if (bs->encrypted) {
++ * @reason: Pointer to the Error used with qdev_add_unplug_blocker.
-                 assert(s->crypto);
++ *          Used as a handle to lookup the blocker for deletion.
-                 if (qcrypto_block_decrypt(s->crypto, sector_num, buf,
++ */
--                                          n * BDRV_SECTOR_SIZE, &err) < 0) {
++void qdev_del_unplug_blocker(DeviceState *dev, Error *reason);
-+                                          n * BDRV_SECTOR_SIZE, NULL) < 0) {
++
-                     goto fail;
++/**
-                 }
++ * qdev_unplug_blocked: Confirm if a device is blocked from unplug
-             }
++ *
-@@ -XXX,XX +XXX,XX @@ done:
++ * @dev: Device to be tested
-     return ret;
++ * @reason: Returns one of the reasons why the device is blocked,
++ *          if any
- fail:
++ *
--    error_free(err);
++ * Returns: true if device is blocked from unplug, false otherwise
-     ret = -EIO;
++ */
-     goto done;
++bool qdev_unplug_blocked(DeviceState *dev, Error **errp);
- }
++
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
+ /**
-             break;
+  * GpioPolarity: Polarity of a GPIO line
-         }
+  *
-         if (bs->encrypted) {
+diff --git a/hw/core/qdev.c b/hw/core/qdev.c
 -            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
+--- a/hw/core/qdev.c
-+++ b/block/qcow2.c
++++ b/hw/core/qdev.c
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
+@@ -XXX,XX +XXX,XX @@ char *qdev_get_dev_path(DeviceState *dev)
                  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;
  }
++void qdev_add_unplug_blocker(DeviceState *dev, Error *reason)
++{
++    dev->unplug_blockers = g_slist_prepend(dev->unplug_blockers, reason);
++}
++
++void qdev_del_unplug_blocker(DeviceState *dev, Error *reason)
++{
++    dev->unplug_blockers = g_slist_remove(dev->unplug_blockers, reason);
++}
++
++bool qdev_unplug_blocked(DeviceState *dev, Error **errp)
++{
++    ERRP_GUARD();
++
++    if (dev->unplug_blockers) {
++        error_propagate(errp, error_copy(dev->unplug_blockers->data));
++        return true;
++    }
++
++    return false;
++}
++
+ static bool device_get_realized(Object *obj, Error **errp)
+ {
+     DeviceState *dev = DEVICE(obj);
+@@ -XXX,XX +XXX,XX @@ static void device_finalize(Object *obj)
+     DeviceState *dev = DEVICE(obj);
++    g_assert(!dev->unplug_blockers);
++
+     QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
+         QLIST_REMOVE(ngl, node);
+         qemu_free_irqs(ngl->in, ngl->num_in);
+diff --git a/softmmu/qdev-monitor.c b/softmmu/qdev-monitor.c
+index XXXXXXX..XXXXXXX 100644
+--- a/softmmu/qdev-monitor.c
++++ b/softmmu/qdev-monitor.c
+@@ -XXX,XX +XXX,XX @@ void qdev_unplug(DeviceState *dev, Error **errp)
+     HotplugHandlerClass *hdc;
+     Error *local_err = NULL;
++    if (qdev_unplug_blocked(dev, errp)) {
++        return;
++    }
++
+     if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
+         error_setg(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
+         return;
 --
-.13.5
+.36.1

-New patch
+[PULL 04/18] remote/machine: add HotplugHandler for remote machine
+From: Jagannathan Raman <jag.raman@oracle.com>
+Allow hotplugging of PCI(e) devices to remote machine
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: d1e6cfa0afb528ad343758f9b1d918be0175c5e5.1655151679.git.jag.raman@oracle.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ hw/remote/machine.c | 10 ++++++++++
+file changed, 10 insertions(+)
+diff --git a/hw/remote/machine.c b/hw/remote/machine.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/remote/machine.c
++++ b/hw/remote/machine.c
+@@ -XXX,XX +XXX,XX @@
+ #include "qapi/error.h"
+ #include "hw/pci/pci_host.h"
+ #include "hw/remote/iohub.h"
++#include "hw/qdev-core.h"
+ static void remote_machine_init(MachineState *machine)
+ {
+@@ -XXX,XX +XXX,XX @@ static void remote_machine_init(MachineState *machine)
+     pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, remote_iohub_map_irq,
+                  &s->iohub, REMOTE_IOHUB_NB_PIRQS);
++
++    qbus_set_hotplug_handler(BUS(pci_host->bus), OBJECT(s));
+ }
+ static void remote_machine_class_init(ObjectClass *oc, void *data)
+ {
+     MachineClass *mc = MACHINE_CLASS(oc);
++    HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
+     mc->init = remote_machine_init;
+     mc->desc = "Experimental remote machine";
++
++    hc->unplug = qdev_simple_device_unplug_cb;
+ }
+ static const TypeInfo remote_machine = {
+@@ -XXX,XX +XXX,XX @@ static const TypeInfo remote_machine = {
+     .parent = TYPE_MACHINE,
+     .instance_size = sizeof(RemoteMachineState),
+     .class_init = remote_machine_class_init,
++    .interfaces = (InterfaceInfo[]) {
++        { TYPE_HOTPLUG_HANDLER },
++        { }
++    }
+ };
+ static void remote_machine_register_types(void)
+--
+.36.1

-New patch
+[PULL 05/18] remote/machine: add vfio-user property
+From: Jagannathan Raman <jag.raman@oracle.com>
+Add vfio-user to x-remote machine. It is a boolean, which indicates if
+the machine supports vfio-user protocol. The machine configures the bus
+differently vfio-user and multiprocess protocols, so this property
+informs it on how to configure the bus.
+This property should be short lived. Once vfio-user fully replaces
+multiprocess, this property could be removed.
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 5d51a152a419cbda35d070b8e49b772b60a7230a.1655151679.git.jag.raman@oracle.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/hw/remote/machine.h |  2 ++
+ hw/remote/machine.c         | 23 +++++++++++++++++++++++
+files changed, 25 insertions(+)
+diff --git a/include/hw/remote/machine.h b/include/hw/remote/machine.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/hw/remote/machine.h
++++ b/include/hw/remote/machine.h
+@@ -XXX,XX +XXX,XX @@ struct RemoteMachineState {
+     RemotePCIHost *host;
+     RemoteIOHubState iohub;
++
++    bool vfio_user;
+ };
+ /* Used to pass to co-routine device and ioc. */
+diff --git a/hw/remote/machine.c b/hw/remote/machine.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/remote/machine.c
++++ b/hw/remote/machine.c
+@@ -XXX,XX +XXX,XX @@ static void remote_machine_init(MachineState *machine)
+     qbus_set_hotplug_handler(BUS(pci_host->bus), OBJECT(s));
+ }
++static bool remote_machine_get_vfio_user(Object *obj, Error **errp)
++{
++    RemoteMachineState *s = REMOTE_MACHINE(obj);
++
++    return s->vfio_user;
++}
++
++static void remote_machine_set_vfio_user(Object *obj, bool value, Error **errp)
++{
++    RemoteMachineState *s = REMOTE_MACHINE(obj);
++
++    if (phase_check(PHASE_MACHINE_CREATED)) {
++        error_setg(errp, "Error enabling vfio-user - machine already created");
++        return;
++    }
++
++    s->vfio_user = value;
++}
++
+ static void remote_machine_class_init(ObjectClass *oc, void *data)
+ {
+     MachineClass *mc = MACHINE_CLASS(oc);
+@@ -XXX,XX +XXX,XX @@ static void remote_machine_class_init(ObjectClass *oc, void *data)
+     mc->desc = "Experimental remote machine";
+     hc->unplug = qdev_simple_device_unplug_cb;
++
++    object_class_property_add_bool(oc, "vfio-user",
++                                   remote_machine_get_vfio_user,
++                                   remote_machine_set_vfio_user);
+ }
+ static const TypeInfo remote_machine = {
+--
+.36.1

-New patch
+[PULL 06/18] vfio-user: build library
+From: Jagannathan Raman <jag.raman@oracle.com>
 add the libvfio-user library as a submodule. build it as a meson
 subproject.
 libvfio-user is distributed with BSD 3-Clause license and
 json-c with MIT (Expat) license
 Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
 Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
 Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: c2adec87958b081d1dc8775d4aa05c897912f025.1655151679.git.jag.raman@oracle.com
 [Changed submodule URL to QEMU's libvfio-user mirror on GitLab. The QEMU
 project mirrors its dependencies so that it can provide full source code
 even in the event that its dependencies become unavailable. Note that
 the mirror repo is manually updated, so please contact me to make newer
 libvfio-user commits available. If I become a bottleneck we can set up a
 cronjob.
 Updated scripts/meson-buildoptions.sh to match the meson_options.txt
 change. Failure to do so can result in scripts/meson-buildoptions.sh
 being modified by the build system later on and you end up with a dirty
 working tree.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  MAINTAINERS                             |  1 +
  meson_options.txt                       |  2 ++
  configure                               | 17 +++++++++++++++++
  meson.build                             | 23 ++++++++++++++++++++++-
  .gitlab-ci.d/buildtest.yml              |  1 +
  .gitmodules                             |  3 +++
  Kconfig.host                            |  4 ++++
  hw/remote/Kconfig                       |  4 ++++
  hw/remote/meson.build                   |  2 ++
  scripts/meson-buildoptions.sh           |  4 ++++
  subprojects/libvfio-user                |  1 +
  tests/docker/dockerfiles/centos8.docker |  2 ++
 files changed, 63 insertions(+), 1 deletion(-)
  create mode 160000 subprojects/libvfio-user
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: hw/remote/proxy-memory-listener.c
  F: include/hw/remote/proxy-memory-listener.h
  F: hw/remote/iohub.c
  F: include/hw/remote/iohub.h
 +F: subprojects/libvfio-user
  EBPF:
  M: Jason Wang <jasowang@redhat.com>
 diff --git a/meson_options.txt b/meson_options.txt
 index XXXXXXX..XXXXXXX 100644
 --- a/meson_options.txt
 +++ b/meson_options.txt
@@ -XXX,XX +XXX,XX @@ option('cfi_debug', type: 'boolean', value: 'false',
         description: 'Verbose errors in case of CFI violation')
  option('multiprocess', type: 'feature', value: 'auto',
         description: 'Out of process device emulation support')
 +option('vfio_user_server', type: 'feature', value: 'disabled',
 +       description: 'vfio-user server support')
  option('dbus_display', type: 'feature', value: 'auto',
         description: '-display dbus support')
  option('tpm', type : 'feature', value : 'auto',
 diff --git a/configure b/configure
 index XXXXXXX..XXXXXXX 100755
 --- a/configure
 +++ b/configure
@@ -XXX,XX +XXX,XX @@ meson_args=""
  ninja=""
  bindir="bin"
  skip_meson=no
 +vfio_user_server="disabled"
  # The following Meson options are handled manually (still they
  # are included in the automatically generated help message)
@@ -XXX,XX +XXX,XX @@ for opt do
    ;;
    --disable-blobs) meson_option_parse --disable-install-blobs ""
    ;;
 +  --enable-vfio-user-server) vfio_user_server="enabled"
 +  ;;
 +  --disable-vfio-user-server) vfio_user_server="disabled"
 +  ;;
    --enable-tcmalloc) meson_option_parse --enable-malloc=tcmalloc tcmalloc
    ;;
    --enable-jemalloc) meson_option_parse --enable-malloc=jemalloc jemalloc
@@ -XXX,XX +XXX,XX @@ write_container_target_makefile() {
 +##########################################
 +# check for vfio_user_server
 +
 +case "$vfio_user_server" in
 +  enabled )
 +    if test "$git_submodules_action" != "ignore"; then
 +      git_submodules="${git_submodules} subprojects/libvfio-user"
 +    fi
 +    ;;
 +esac
 +
  ##########################################
  # End of CC checks
  # After here, no more $cc or $ld runs
@@ -XXX,XX +XXX,XX @@ if test "$skip_meson" = no; then
    test "$slirp" != auto && meson_option_add "-Dslirp=$slirp"
    test "$smbd" != '' && meson_option_add "-Dsmbd=$smbd"
    test "$tcg" != enabled && meson_option_add "-Dtcg=$tcg"
 +  test "$vfio_user_server" != auto && meson_option_add "-Dvfio_user_server=$vfio_user_server"
    run_meson() {
      NINJA=$ninja $meson setup --prefix "$prefix" "$@" $cross_arg "$PWD" "$source_path"
    }
 diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/meson.build
 +++ b/meson.build
@@ -XXX,XX +XXX,XX @@ multiprocess_allowed = get_option('multiprocess') \
    .require(targetos == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
    .allowed()
 +vfio_user_server_allowed = get_option('vfio_user_server') \
 +  .require(targetos == 'linux', error_message: 'vfio-user server is supported only on Linux') \
 +  .allowed()
 +
  have_tpm = get_option('tpm') \
    .require(targetos != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
    .allowed()
@@ -XXX,XX +XXX,XX @@ host_kconfig = \
    (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
    ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
    (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
 -  (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
 +  (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
 +  (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : [])
  ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
@@ -XXX,XX +XXX,XX @@ if have_system
    endif
  endif
 +libvfio_user_dep = not_found
 +if have_system and vfio_user_server_allowed
 +  have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build')
 +
 +  if not have_internal
 +    error('libvfio-user source not found - please pull git submodule')
 +  endif
 +
 +  libvfio_user_proj = subproject('libvfio-user')
 +
 +  libvfio_user_lib = libvfio_user_proj.get_variable('libvfio_user_dep')
 +
 +  libvfio_user_dep = declare_dependency(dependencies: [libvfio_user_lib])
 +endif
 +
  fdt = not_found
  if have_system
    fdt_opt = get_option('fdt')
@@ -XXX,XX +XXX,XX @@ summary_info += {'target list':       ' '.join(target_dirs)}
  if have_system
    summary_info += {'default devices':   get_option('default_devices')}
    summary_info += {'out of process emulation': multiprocess_allowed}
 +  summary_info += {'vfio-user server': vfio_user_server_allowed}
  endif
  summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
 diff --git a/.gitlab-ci.d/buildtest.yml b/.gitlab-ci.d/buildtest.yml
 index XXXXXXX..XXXXXXX 100644
 --- a/.gitlab-ci.d/buildtest.yml
 +++ b/.gitlab-ci.d/buildtest.yml
@@ -XXX,XX +XXX,XX @@ build-system-centos:
      IMAGE: centos8
      CONFIGURE_ARGS: --disable-nettle --enable-gcrypt --enable-fdt=system
        --enable-modules --enable-trace-backends=dtrace --enable-docs
 +      --enable-vfio-user-server
      TARGETS: ppc64-softmmu or1k-softmmu s390x-softmmu
        x86_64-softmmu rx-softmmu sh4-softmmu nios2-softmmu
      MAKE_CHECK_ARGS: check-build
 diff --git a/.gitmodules b/.gitmodules
 index XXXXXXX..XXXXXXX 100644
 --- a/.gitmodules
 +++ b/.gitmodules
@@ -XXX,XX +XXX,XX @@
  [submodule "tests/lcitool/libvirt-ci"]
      path = tests/lcitool/libvirt-ci
      url = https://gitlab.com/libvirt/libvirt-ci.git
 +[submodule "subprojects/libvfio-user"]
 +    path = subprojects/libvfio-user
 +    url = https://gitlab.com/qemu-project/libvfio-user.git
 diff --git a/Kconfig.host b/Kconfig.host
 index XXXXXXX..XXXXXXX 100644
 --- a/Kconfig.host
 +++ b/Kconfig.host
@@ -XXX,XX +XXX,XX @@ config MULTIPROCESS_ALLOWED
  config FUZZ
      bool
      select SPARSE_MEM
 +
 +config VFIO_USER_SERVER_ALLOWED
 +    bool
 +    imply VFIO_USER_SERVER
 diff --git a/hw/remote/Kconfig b/hw/remote/Kconfig
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/Kconfig
 +++ b/hw/remote/Kconfig
@@ -XXX,XX +XXX,XX @@ config MULTIPROCESS
      bool
      depends on PCI && PCI_EXPRESS && KVM
      select REMOTE_PCIHOST
 +
 +config VFIO_USER_SERVER
 +    bool
 +    depends on MULTIPROCESS
 diff --git a/hw/remote/meson.build b/hw/remote/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/meson.build
 +++ b/hw/remote/meson.build
@@ -XXX,XX +XXX,XX @@ remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('remote-obj.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('proxy.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('iohub.c'))
 +remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: libvfio_user_dep)
 +
  specific_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('memory.c'))
  specific_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('proxy-memory-listener.c'))
 diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
 index XXXXXXX..XXXXXXX 100644
 --- a/scripts/meson-buildoptions.sh
 +++ b/scripts/meson-buildoptions.sh
@@ -XXX,XX +XXX,XX @@ meson_options_help() {
    printf "%s\n" '  usb-redir       libusbredir support'
    printf "%s\n" '  vde             vde network backend support'
    printf "%s\n" '  vdi             vdi image format support'
 +  printf "%s\n" '  vfio-user-server'
 +  printf "%s\n" '                  vfio-user server support'
    printf "%s\n" '  vhost-crypto    vhost-user crypto backend support'
    printf "%s\n" '  vhost-kernel    vhost kernel backend support'
    printf "%s\n" '  vhost-net       vhost-net kernel acceleration support'
@@ -XXX,XX +XXX,XX @@ _meson_option_parse() {
      --disable-vde) printf "%s" -Dvde=disabled ;;
      --enable-vdi) printf "%s" -Dvdi=enabled ;;
      --disable-vdi) printf "%s" -Dvdi=disabled ;;
 +    --enable-vfio-user-server) printf "%s" -Dvfio_user_server=enabled ;;
 +    --disable-vfio-user-server) printf "%s" -Dvfio_user_server=disabled ;;
      --enable-vhost-crypto) printf "%s" -Dvhost_crypto=enabled ;;
      --disable-vhost-crypto) printf "%s" -Dvhost_crypto=disabled ;;
      --enable-vhost-kernel) printf "%s" -Dvhost_kernel=enabled ;;
 diff --git a/subprojects/libvfio-user b/subprojects/libvfio-user
 new file mode 160000
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/subprojects/libvfio-user
@@ -0,0 +1 @@
 +Subproject commit 0b28d205572c80b568a1003db2c8f37ca333e4d7
 diff --git a/tests/docker/dockerfiles/centos8.docker b/tests/docker/dockerfiles/centos8.docker
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/docker/dockerfiles/centos8.docker
 +++ b/tests/docker/dockerfiles/centos8.docker
@@ -XXX,XX +XXX,XX @@ RUN dnf update -y && \
          libbpf-devel \
          libcacard-devel \
          libcap-ng-devel \
 +        libcmocka-devel \
          libcurl-devel \
          libdrm-devel \
          libepoxy-devel \
@@ -XXX,XX +XXX,XX @@ RUN dnf update -y && \
          libgcrypt-devel \
          libiscsi-devel \
          libjpeg-devel \
 +        json-c-devel \
          libnfs-devel \
          libpmem-devel \
          libpng-devel \
 --
 .36.1

-[Qemu-devel] [PULL for-2.10 13/15] tests: migration/guestperf Python 2.6 argparse compatibility
+[PULL 07/18] vfio-user: define vfio-user-server object
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+From: Jagannathan Raman <jag.raman@oracle.com>
-import argparse.
+Define vfio-user object which is remote process server for QEMU. Setup
-Cc: Daniel P. Berrange <berrange@redhat.com>
+object initialization functions and properties necessary to instantiate
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+the object
-Acked-by: John Snow <jsnow@redhat.com>
-Acked-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-Message-id: 20170825155732.15665-4-stefanha@redhat.com
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
 Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: e45a17001e9b38f451543a664ababdf860e5f2f2.1655151679.git.jag.raman@oracle.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/migration/guestperf/shell.py | 8 +++++---
+ MAINTAINERS                 |   1 +
-file changed, 5 insertions(+), 3 deletions(-)
+ qapi/qom.json               |  20 +++-
+ include/hw/remote/machine.h |   2 +
-diff --git a/tests/migration/guestperf/shell.py b/tests/migration/guestperf/shell.py
+ hw/remote/machine.c         |  27 +++++
-index XXXXXXX..XXXXXXX 100644
+ hw/remote/vfio-user-obj.c   | 210 ++++++++++++++++++++++++++++++++++++
---- a/tests/migration/guestperf/shell.py
+ hw/remote/meson.build       |   1 +
-+++ b/tests/migration/guestperf/shell.py
+ hw/remote/trace-events      |   3 +
-@@ -XXX,XX +XXX,XX @@
+files changed, 262 insertions(+), 2 deletions(-)
  create mode 100644 hw/remote/vfio-user-obj.c
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: include/hw/remote/proxy-memory-listener.h
  F: hw/remote/iohub.c
  F: include/hw/remote/iohub.h
  F: subprojects/libvfio-user
 +F: hw/remote/vfio-user-obj.c
  EBPF:
  M: Jason Wang <jasowang@redhat.com>
 diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/qom.json
 +++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
  { 'struct': 'RemoteObjectProperties',
    'data': { 'fd': 'str', 'devid': 'str' } }
 +##
 +# @VfioUserServerProperties:
 +#
 +# Properties for x-vfio-user-server objects.
 +#
 +# @socket: socket to be used by the libvfio-user library
 +#
 +# @device: the ID of the device to be emulated at the server
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'VfioUserServerProperties',
 +  'data': { 'socket': 'SocketAddress', 'device': 'str' } }
 +
  ##
  # @RngProperties:
  #
+@@ -XXX,XX +XXX,XX @@
+     'tls-creds-psk',
--import argparse
+     'tls-creds-x509',
--import fnmatch
+     'tls-cipher-suites',
- import os
+-    { 'name': 'x-remote-object', 'features': [ 'unstable' ] }
- import os.path
++    { 'name': 'x-remote-object', 'features': [ 'unstable' ] },
--import platform
++    { 'name': 'x-vfio-user-server', 'features': [ 'unstable' ] }
- import sys
+   ] }
-+sys.path.append(os.path.join(os.path.dirname(__file__),
-+                             '..', '..', '..', 'scripts'))
+ ##
-+import argparse
+@@ -XXX,XX +XXX,XX @@
-+import fnmatch
+       'tls-creds-psk':              'TlsCredsPskProperties',
-+import platform
+       'tls-creds-x509':             'TlsCredsX509Properties',
+       'tls-cipher-suites':          'TlsCredsProperties',
- from guestperf.hardware import Hardware
+-      'x-remote-object':            'RemoteObjectProperties'
- from guestperf.engine import Engine
++      'x-remote-object':            'RemoteObjectProperties',
 +      'x-vfio-user-server':         'VfioUserServerProperties'
    } }
  ##
 diff --git a/include/hw/remote/machine.h b/include/hw/remote/machine.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/hw/remote/machine.h
 +++ b/include/hw/remote/machine.h
@@ -XXX,XX +XXX,XX @@ struct RemoteMachineState {
      RemoteIOHubState iohub;
      bool vfio_user;
 +
 +    bool auto_shutdown;
  };
  /* Used to pass to co-routine device and ioc. */
 diff --git a/hw/remote/machine.c b/hw/remote/machine.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/machine.c
 +++ b/hw/remote/machine.c
@@ -XXX,XX +XXX,XX @@ static void remote_machine_set_vfio_user(Object *obj, bool value, Error **errp)
      s->vfio_user = value;
  }
 +static bool remote_machine_get_auto_shutdown(Object *obj, Error **errp)
 +{
 +    RemoteMachineState *s = REMOTE_MACHINE(obj);
 +
 +    return s->auto_shutdown;
 +}
 +
 +static void remote_machine_set_auto_shutdown(Object *obj, bool value,
 +                                             Error **errp)
 +{
 +    RemoteMachineState *s = REMOTE_MACHINE(obj);
 +
 +    s->auto_shutdown = value;
 +}
 +
 +static void remote_machine_instance_init(Object *obj)
 +{
 +    RemoteMachineState *s = REMOTE_MACHINE(obj);
 +
 +    s->auto_shutdown = true;
 +}
 +
  static void remote_machine_class_init(ObjectClass *oc, void *data)
  {
      MachineClass *mc = MACHINE_CLASS(oc);
@@ -XXX,XX +XXX,XX @@ static void remote_machine_class_init(ObjectClass *oc, void *data)
      object_class_property_add_bool(oc, "vfio-user",
                                     remote_machine_get_vfio_user,
                                     remote_machine_set_vfio_user);
 +
 +    object_class_property_add_bool(oc, "auto-shutdown",
 +                                   remote_machine_get_auto_shutdown,
 +                                   remote_machine_set_auto_shutdown);
  }
  static const TypeInfo remote_machine = {
      .name = TYPE_REMOTE_MACHINE,
      .parent = TYPE_MACHINE,
      .instance_size = sizeof(RemoteMachineState),
 +    .instance_init = remote_machine_instance_init,
      .class_init = remote_machine_class_init,
      .interfaces = (InterfaceInfo[]) {
          { TYPE_HOTPLUG_HANDLER },
 diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
 +/**
 + * QEMU vfio-user-server server object
 + *
 + * Copyright © 2022 Oracle and/or its affiliates.
 + *
 + * This work is licensed under the terms of the GNU GPL-v2, version 2 or later.
 + *
 + * See the COPYING file in the top-level directory.
 + *
 + */
 +
 +/**
 + * Usage: add options:
 + *     -machine x-remote,vfio-user=on,auto-shutdown=on
 + *     -device <PCI-device>,id=<pci-dev-id>
 + *     -object x-vfio-user-server,id=<id>,type=unix,path=<socket-path>,
 + *             device=<pci-dev-id>
 + *
 + * Note that x-vfio-user-server object must be used with x-remote machine only.
 + * This server could only support PCI devices for now.
 + *
 + * type - SocketAddress type - presently "unix" alone is supported. Required
 + *        option
 + *
 + * path - named unix socket, it will be created by the server. It is
 + *        a required option
 + *
 + * device - id of a device on the server, a required option. PCI devices
 + *          alone are supported presently.
 + */
 +
 +#include "qemu/osdep.h"
 +
 +#include "qom/object.h"
 +#include "qom/object_interfaces.h"
 +#include "qemu/error-report.h"
 +#include "trace.h"
 +#include "sysemu/runstate.h"
 +#include "hw/boards.h"
 +#include "hw/remote/machine.h"
 +#include "qapi/error.h"
 +#include "qapi/qapi-visit-sockets.h"
 +
 +#define TYPE_VFU_OBJECT "x-vfio-user-server"
 +OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
 +
 +/**
 + * VFU_OBJECT_ERROR - reports an error message. If auto_shutdown
 + * is set, it aborts the machine on error. Otherwise, it logs an
 + * error message without aborting.
 + */
 +#define VFU_OBJECT_ERROR(o, fmt, ...)                                     \
 +    {                                                                     \
 +        if (vfu_object_auto_shutdown()) {                                 \
 +            error_setg(&error_abort, (fmt), ## __VA_ARGS__);              \
 +        } else {                                                          \
 +            error_report((fmt), ## __VA_ARGS__);                          \
 +        }                                                                 \
 +    }                                                                     \
 +
 +struct VfuObjectClass {
 +    ObjectClass parent_class;
 +
 +    unsigned int nr_devs;
 +};
 +
 +struct VfuObject {
 +    /* private */
 +    Object parent;
 +
 +    SocketAddress *socket;
 +
 +    char *device;
 +
 +    Error *err;
 +};
 +
 +static bool vfu_object_auto_shutdown(void)
 +{
 +    bool auto_shutdown = true;
 +    Error *local_err = NULL;
 +
 +    if (!current_machine) {
 +        return auto_shutdown;
 +    }
 +
 +    auto_shutdown = object_property_get_bool(OBJECT(current_machine),
 +                                             "auto-shutdown",
 +                                             &local_err);
 +
 +    /*
 +     * local_err would be set if no such property exists - safe to ignore.
 +     * Unlikely scenario as auto-shutdown is always defined for
 +     * TYPE_REMOTE_MACHINE, and  TYPE_VFU_OBJECT only works with
 +     * TYPE_REMOTE_MACHINE
 +     */
 +    if (local_err) {
 +        auto_shutdown = true;
 +        error_free(local_err);
 +    }
 +
 +    return auto_shutdown;
 +}
 +
 +static void vfu_object_set_socket(Object *obj, Visitor *v, const char *name,
 +                                  void *opaque, Error **errp)
 +{
 +    VfuObject *o = VFU_OBJECT(obj);
 +
 +    qapi_free_SocketAddress(o->socket);
 +
 +    o->socket = NULL;
 +
 +    visit_type_SocketAddress(v, name, &o->socket, errp);
 +
 +    if (o->socket->type != SOCKET_ADDRESS_TYPE_UNIX) {
 +        error_setg(errp, "vfu: Unsupported socket type - %s",
 +                   SocketAddressType_str(o->socket->type));
 +        qapi_free_SocketAddress(o->socket);
 +        o->socket = NULL;
 +        return;
 +    }
 +
 +    trace_vfu_prop("socket", o->socket->u.q_unix.path);
 +}
 +
 +static void vfu_object_set_device(Object *obj, const char *str, Error **errp)
 +{
 +    VfuObject *o = VFU_OBJECT(obj);
 +
 +    g_free(o->device);
 +
 +    o->device = g_strdup(str);
 +
 +    trace_vfu_prop("device", str);
 +}
 +
 +static void vfu_object_init(Object *obj)
 +{
 +    VfuObjectClass *k = VFU_OBJECT_GET_CLASS(obj);
 +    VfuObject *o = VFU_OBJECT(obj);
 +
 +    k->nr_devs++;
 +
 +    if (!object_dynamic_cast(OBJECT(current_machine), TYPE_REMOTE_MACHINE)) {
 +        error_setg(&o->err, "vfu: %s only compatible with %s machine",
 +                   TYPE_VFU_OBJECT, TYPE_REMOTE_MACHINE);
 +        return;
 +    }
 +}
 +
 +static void vfu_object_finalize(Object *obj)
 +{
 +    VfuObjectClass *k = VFU_OBJECT_GET_CLASS(obj);
 +    VfuObject *o = VFU_OBJECT(obj);
 +
 +    k->nr_devs--;
 +
 +    qapi_free_SocketAddress(o->socket);
 +
 +    o->socket = NULL;
 +
 +    g_free(o->device);
 +
 +    o->device = NULL;
 +
 +    if (!k->nr_devs && vfu_object_auto_shutdown()) {
 +        qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
 +    }
 +}
 +
 +static void vfu_object_class_init(ObjectClass *klass, void *data)
 +{
 +    VfuObjectClass *k = VFU_OBJECT_CLASS(klass);
 +
 +    k->nr_devs = 0;
 +
 +    object_class_property_add(klass, "socket", "SocketAddress", NULL,
 +                              vfu_object_set_socket, NULL, NULL);
 +    object_class_property_set_description(klass, "socket",
 +                                          "SocketAddress "
 +                                          "(ex: type=unix,path=/tmp/sock). "
 +                                          "Only UNIX is presently supported");
 +    object_class_property_add_str(klass, "device", NULL,
 +                                  vfu_object_set_device);
 +    object_class_property_set_description(klass, "device",
 +                                          "device ID - only PCI devices "
 +                                          "are presently supported");
 +}
 +
 +static const TypeInfo vfu_object_info = {
 +    .name = TYPE_VFU_OBJECT,
 +    .parent = TYPE_OBJECT,
 +    .instance_size = sizeof(VfuObject),
 +    .instance_init = vfu_object_init,
 +    .instance_finalize = vfu_object_finalize,
 +    .class_size = sizeof(VfuObjectClass),
 +    .class_init = vfu_object_class_init,
 +    .interfaces = (InterfaceInfo[]) {
 +        { TYPE_USER_CREATABLE },
 +        { }
 +    }
 +};
 +
 +static void vfu_register_types(void)
 +{
 +    type_register_static(&vfu_object_info);
 +}
 +
 +type_init(vfu_register_types);
 diff --git a/hw/remote/meson.build b/hw/remote/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/meson.build
 +++ b/hw/remote/meson.build
@@ -XXX,XX +XXX,XX @@ remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('message.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('remote-obj.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('proxy.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('iohub.c'))
 +remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: files('vfio-user-obj.c'))
  remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: libvfio_user_dep)
 diff --git a/hw/remote/trace-events b/hw/remote/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/trace-events
 +++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@
  mpqemu_send_io_error(int cmd, int size, int nfds) "send command %d size %d, %d file descriptors to remote process"
  mpqemu_recv_io_error(int cmd, int size, int nfds) "failed to receive %d size %d, %d file descriptors to remote process"
 +
 +# vfio-user-obj.c
 +vfu_prop(const char *prop, const char *val) "vfu: setting %s as %s"
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 05/15] throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
+[PULL 08/18] vfio-user: instantiate vfio-user context
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-The throttling code can change internally the value of bkt->max if it
+create a context with the vfio-user library to run a PCI device
 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>
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
-Message-id: 5b0b9e1ac6eb208d709eddc7b09e7669a523bff3.1503580370.git.berto@igalia.com
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: a452871ac8c812ff96fc4f0ce6037f4769953fab.1655151679.git.jag.raman@oracle.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- util/throttle.c | 62 +++++++++++++++++++++------------------------------------
+ hw/remote/vfio-user-obj.c | 82 +++++++++++++++++++++++++++++++++++++++
-file changed, 23 insertions(+), 39 deletions(-)
+file changed, 82 insertions(+)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/hw/remote/vfio-user-obj.c
-+++ b/util/throttle.c
++++ b/hw/remote/vfio-user-obj.c
-@@ -XXX,XX +XXX,XX @@ static int64_t throttle_do_compute_wait(double limit, double extra)
+@@ -XXX,XX +XXX,XX @@
- int64_t throttle_compute_wait(LeakyBucket *bkt)
+ #include "hw/remote/machine.h"
  #include "qapi/error.h"
  #include "qapi/qapi-visit-sockets.h"
 +#include "qemu/notify.h"
 +#include "sysemu/sysemu.h"
 +#include "libvfio-user.h"
  #define TYPE_VFU_OBJECT "x-vfio-user-server"
  OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
@@ -XXX,XX +XXX,XX @@ struct VfuObject {
      char *device;
      Error *err;
 +
 +    Notifier machine_done;
 +
 +    vfu_ctx_t *vfu_ctx;
  };
 +static void vfu_object_init_ctx(VfuObject *o, Error **errp);
 +
  static bool vfu_object_auto_shutdown(void)
  {
-     double extra; /* the number of extra units blocking the io */
+     bool auto_shutdown = true;
-+    double bucket_size;   /* I/O before throttling to bkt->avg */
+@@ -XXX,XX +XXX,XX @@ static void vfu_object_set_socket(Object *obj, Visitor *v, const char *name,
-+    double burst_bucket_size; /* Before throttling to bkt->max */
+ {
+     VfuObject *o = VFU_OBJECT(obj);
-     if (!bkt->avg) {
-         return 0;
++    if (o->vfu_ctx) {
-     }
++        error_setg(errp, "vfu: Unable to set socket property - server busy");
++        return;
 -    /* 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 */
+     qapi_free_SocketAddress(o->socket);
-+    extra = bkt->level - bucket_size;
-     if (extra > 0) {
+     o->socket = NULL;
-         return throttle_do_compute_wait(bkt->avg, extra);
+@@ -XXX,XX +XXX,XX @@ static void vfu_object_set_socket(Object *obj, Visitor *v, const char *name,
      }
--    /* If the bucket is not full yet we have to make sure that we
+     trace_vfu_prop("socket", o->socket->u.q_unix.path);
--     * fulfill the goal of bkt->max units per second. */
++
-+    /* If the main bucket is not full yet we still have to check the
++    vfu_object_init_ctx(o, errp);
 +     * 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 vfu_object_set_device(Object *obj, const char *str, Error **errp)
--static void throttle_fix_bucket(LeakyBucket *bkt)
+ {
--{
+     VfuObject *o = VFU_OBJECT(obj);
--    double min;
--
++    if (o->vfu_ctx) {
--    /* zero bucket level */
++        error_setg(errp, "vfu: Unable to set device property - server busy");
--    bkt->level = bkt->burst_level = 0;
++        return;
--
++    }
--    /* 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
+     g_free(o->device);
--     * and performance will suffer considerably. */
--    min = bkt->avg / 10;
+     o->device = g_strdup(str);
--    if (bkt->avg && !bkt->max) {
--        bkt->max = min;
+     trace_vfu_prop("device", str);
--    }
++
--}
++    vfu_object_init_ctx(o, errp);
--
++}
--/* undo internal bucket parameter changes (see throttle_fix_bucket()) */
++
--static void throttle_unfix_bucket(LeakyBucket *bkt)
++/*
--{
++ * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
--    if (bkt->max < bkt->avg) {
++ * properties. It also depends on devices instantiated in QEMU. These
--        bkt->max = 0;
++ * dependencies are not available during the instance_init phase of this
--    }
++ * object's life-cycle. As such, the server is initialized after the
--}
++ * machine is setup. machine_init_done_notifier notifies TYPE_VFU_OBJECT
--
++ * when the machine is setup, and the dependencies are available.
- /* Used to configure the throttle
++ */
-  *
++static void vfu_object_machine_done(Notifier *notifier, void *data)
-  * @ts: the throttle state we are working on
++{
-@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
++    VfuObject *o = container_of(notifier, VfuObject, machine_done);
++    Error *err = NULL;
-     ts->cfg = *cfg;
++
++    vfu_object_init_ctx(o, &err);
-+    /* Zero bucket level */
++
-     for (i = 0; i < BUCKETS_COUNT; i++) {
++    if (err) {
--        throttle_fix_bucket(&ts->cfg.buckets[i]);
++        error_propagate(&error_abort, err);
-+        ts->cfg.buckets[i].level = 0;
++    }
-+        ts->cfg.buckets[i].burst_level = 0;
++}
 +
 +static void vfu_object_init_ctx(VfuObject *o, Error **errp)
 +{
 +    ERRP_GUARD();
 +
 +    if (o->vfu_ctx || !o->socket || !o->device ||
 +            !phase_check(PHASE_MACHINE_READY)) {
 +        return;
 +    }
 +
 +    if (o->err) {
 +        error_propagate(errp, o->err);
 +        o->err = NULL;
 +        return;
 +    }
 +
 +    o->vfu_ctx = vfu_create_ctx(VFU_TRANS_SOCK, o->socket->u.q_unix.path, 0,
 +                                o, VFU_DEV_TYPE_PCI);
 +    if (o->vfu_ctx == NULL) {
 +        error_setg(errp, "vfu: Failed to create context - %s", strerror(errno));
 +        return;
 +    }
  }
  static void vfu_object_init(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init(Object *obj)
                     TYPE_VFU_OBJECT, TYPE_REMOTE_MACHINE);
          return;
      }
++
-     ts->previous_leak = qemu_clock_get_ns(clock_type);
++    if (!phase_check(PHASE_MACHINE_READY)) {
-@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
++        o->machine_done.notify = vfu_object_machine_done;
-  */
++        qemu_add_machine_init_done_notifier(&o->machine_done);
- 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]);
 -    }
  }
+ static void vfu_object_finalize(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
      o->socket = NULL;
 +    if (o->vfu_ctx) {
 +        vfu_destroy_ctx(o->vfu_ctx);
 +        o->vfu_ctx = NULL;
 +    }
 +
      g_free(o->device);
      o->device = NULL;
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
      if (!k->nr_devs && vfu_object_auto_shutdown()) {
          qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
      }
 +
 +    if (o->machine_done.notify) {
 +        qemu_remove_machine_init_done_notifier(&o->machine_done);
 +        o->machine_done.notify = NULL;
 +    }
  }
  static void vfu_object_class_init(ObjectClass *klass, void *data)
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 07/15] throttle: Make burst_length 64bit and add range checks
+[PULL 09/18] vfio-user: find and init PCI device
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-LeakyBucket.burst_length is defined as an unsigned integer but the
+Find the PCI device with specified id. Initialize the device context
-code never checks for overflows and it only makes sure that the value
+with the QEMU PCI device
 is not 0.
-In practice this means that the user can set something like
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-throttling.iops-total-max-length=4294967300 despite being larger than
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
-UINT_MAX and the final value after casting to unsigned int will be 4.
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-This patch changes the data type to uint64_t. This does not increase
+Message-id: 7798dbd730099b33fdd00c4c202cfe79e5c5c151.1655151679.git.jag.raman@oracle.com
 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 +-
+ hw/remote/vfio-user-obj.c | 67 +++++++++++++++++++++++++++++++++++++++
- util/throttle.c         | 5 +++++
+file changed, 67 insertions(+)
 files changed, 6 insertions(+), 1 deletion(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/hw/remote/vfio-user-obj.c
-+++ b/include/qemu/throttle.h
++++ b/hw/remote/vfio-user-obj.c
-@@ -XXX,XX +XXX,XX @@ typedef struct LeakyBucket {
+@@ -XXX,XX +XXX,XX @@
-     uint64_t max;             /* leaky bucket max burst in units */
+ #include "qemu/notify.h"
-     double  level;            /* bucket level in units */
+ #include "sysemu/sysemu.h"
-     double  burst_level;      /* bucket level in units (for computing bursts) */
+ #include "libvfio-user.h"
--    unsigned burst_length;    /* max length of the burst period, in seconds */
++#include "hw/qdev-core.h"
-+    uint64_t burst_length;    /* max length of the burst period, in seconds */
++#include "hw/pci/pci.h"
- } LeakyBucket;
+ #define TYPE_VFU_OBJECT "x-vfio-user-server"
- /* The following structure is used to configure a ThrottleState
+ OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
-diff --git a/util/throttle.c b/util/throttle.c
+@@ -XXX,XX +XXX,XX @@ struct VfuObject {
-index XXXXXXX..XXXXXXX 100644
+     Notifier machine_done;
---- a/util/throttle.c
-+++ b/util/throttle.c
+     vfu_ctx_t *vfu_ctx;
@@ -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) {
++    PCIDevice *pci_dev;
-             error_setg(errp, "bps_max/iops_max require corresponding"
++
-                        " bps/iops values");
++    Error *unplug_blocker;
  };
  static void vfu_object_init_ctx(VfuObject *o, Error **errp);
@@ -XXX,XX +XXX,XX @@ static void vfu_object_machine_done(Notifier *notifier, void *data)
  static void vfu_object_init_ctx(VfuObject *o, Error **errp)
  {
      ERRP_GUARD();
 +    DeviceState *dev = NULL;
 +    vfu_pci_type_t pci_type = VFU_PCI_TYPE_CONVENTIONAL;
 +    int ret;
      if (o->vfu_ctx || !o->socket || !o->device ||
              !phase_check(PHASE_MACHINE_READY)) {
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
          error_setg(errp, "vfu: Failed to create context - %s", strerror(errno));
          return;
      }
 +
 +    dev = qdev_find_recursive(sysbus_get_default(), o->device);
 +    if (dev == NULL) {
 +        error_setg(errp, "vfu: Device %s not found", o->device);
 +        goto fail;
 +    }
 +
 +    if (!object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
 +        error_setg(errp, "vfu: %s not a PCI device", o->device);
 +        goto fail;
 +    }
 +
 +    o->pci_dev = PCI_DEVICE(dev);
 +
 +    object_ref(OBJECT(o->pci_dev));
 +
 +    if (pci_is_express(o->pci_dev)) {
 +        pci_type = VFU_PCI_TYPE_EXPRESS;
 +    }
 +
 +    ret = vfu_pci_init(o->vfu_ctx, pci_type, PCI_HEADER_TYPE_NORMAL, 0);
 +    if (ret < 0) {
 +        error_setg(errp,
 +                   "vfu: Failed to attach PCI device %s to context - %s",
 +                   o->device, strerror(errno));
 +        goto fail;
 +    }
 +
 +    error_setg(&o->unplug_blocker,
 +               "vfu: %s for %s must be deleted before unplugging",
 +               TYPE_VFU_OBJECT, o->device);
 +    qdev_add_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
 +
 +    return;
 +
 +fail:
 +    vfu_destroy_ctx(o->vfu_ctx);
 +    if (o->unplug_blocker && o->pci_dev) {
 +        qdev_del_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
 +        error_free(o->unplug_blocker);
 +        o->unplug_blocker = NULL;
 +    }
 +    if (o->pci_dev) {
 +        object_unref(OBJECT(o->pci_dev));
 +        o->pci_dev = NULL;
 +    }
 +    o->vfu_ctx = NULL;
  }
  static void vfu_object_init(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
      o->device = NULL;
 +    if (o->unplug_blocker && o->pci_dev) {
 +        qdev_del_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
 +        error_free(o->unplug_blocker);
 +        o->unplug_blocker = NULL;
 +    }
 +
 +    if (o->pci_dev) {
 +        object_unref(OBJECT(o->pci_dev));
 +        o->pci_dev = NULL;
 +    }
 +
      if (!k->nr_devs && vfu_object_auto_shutdown()) {
          qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
      }
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 06/15] throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
+[PULL 10/18] vfio-user: run vfio-user context
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-Both the throttling limits set with the throttling.iops-* and
+Setup a handler to run vfio-user context. The context is driven by
-throttling.bps-* options and their QMP equivalents defined in the
+messages to the file descriptor associated with it - get the fd for
-BlockIOThrottle struct are integer values.
+the context and hook up the handler with it
-Those limits are also reported in the BlockDeviceInfo struct and they
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-are integers there as well.
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
-Therefore there's no reason to store them internally as double and do
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-the conversion everytime we're setting or querying them, so this patch
+Message-id: e934b0090529d448b6a7972b21dfc3d7421ce494.1655151679.git.jag.raman@oracle.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 ++--
+ qapi/misc.json            |  31 ++++++++++
- tests/test-throttle.c   | 3 ++-
+ hw/remote/vfio-user-obj.c | 118 +++++++++++++++++++++++++++++++++++++-
- util/throttle.c         | 7 +++----
+files changed, 148 insertions(+), 1 deletion(-)
 files changed, 7 insertions(+), 7 deletions(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/qapi/misc.json b/qapi/misc.json
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/qapi/misc.json
-+++ b/include/qemu/throttle.h
++++ b/qapi/misc.json
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@
  ##
  { 'event': 'RTC_CHANGE',
    'data': { 'offset': 'int', 'qom-path': 'str' } }
 +
 +##
 +# @VFU_CLIENT_HANGUP:
 +#
 +# Emitted when the client of a TYPE_VFIO_USER_SERVER closes the
 +# communication channel
 +#
 +# @vfu-id: ID of the TYPE_VFIO_USER_SERVER object. It is the last component
 +#          of @vfu-qom-path referenced below
 +#
 +# @vfu-qom-path: path to the TYPE_VFIO_USER_SERVER object in the QOM tree
 +#
 +# @dev-id: ID of attached PCI device
 +#
 +# @dev-qom-path: path to attached PCI device in the QOM tree
 +#
 +# Since: 7.1
 +#
 +# Example:
 +#
 +# <- { "event": "VFU_CLIENT_HANGUP",
 +#      "data": { "vfu-id": "vfu1",
 +#                "vfu-qom-path": "/objects/vfu1",
 +#                "dev-id": "sas1",
 +#                "dev-qom-path": "/machine/peripheral/sas1" },
 +#      "timestamp": { "seconds": 1265044230, "microseconds": 450486 } }
 +#
 +##
 +{ 'event': 'VFU_CLIENT_HANGUP',
 +  'data': { 'vfu-id': 'str', 'vfu-qom-path': 'str',
 +            'dev-id': 'str', 'dev-qom-path': 'str' } }
 diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/vfio-user-obj.c
 +++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
   *
   * device - id of a device on the server, a required option. PCI devices
   *          alone are supported presently.
 + *
 + * notes - x-vfio-user-server could block IO and monitor during the
 + *         initialization phase.
   */
- typedef struct LeakyBucket {
+ #include "qemu/osdep.h"
--    double  avg;              /* average goal in units per second */
+@@ -XXX,XX +XXX,XX @@
--    double  max;              /* leaky bucket max burst in units */
+ #include "hw/remote/machine.h"
-+    uint64_t avg;             /* average goal in units per second */
+ #include "qapi/error.h"
-+    uint64_t max;             /* leaky bucket max burst in units */
+ #include "qapi/qapi-visit-sockets.h"
-     double  level;            /* bucket level in units */
++#include "qapi/qapi-events-misc.h"
-     double  burst_level;      /* bucket level in units (for computing bursts) */
+ #include "qemu/notify.h"
-     unsigned burst_length;    /* max length of the burst period, in seconds */
++#include "qemu/thread.h"
-diff --git a/tests/test-throttle.c b/tests/test-throttle.c
+ #include "sysemu/sysemu.h"
-index XXXXXXX..XXXXXXX 100644
+ #include "libvfio-user.h"
---- a/tests/test-throttle.c
+ #include "hw/qdev-core.h"
-+++ b/tests/test-throttle.c
+ #include "hw/pci/pci.h"
-@@ -XXX,XX +XXX,XX @@ static void test_enabled(void)
++#include "qemu/timer.h"
-     for (i = 0; i < BUCKETS_COUNT; i++) {
-         throttle_config_init(&cfg);
+ #define TYPE_VFU_OBJECT "x-vfio-user-server"
-         set_cfg_value(false, i, 150);
+ OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
-+        g_assert(throttle_is_valid(&cfg, NULL));
+@@ -XXX,XX +XXX,XX @@ struct VfuObject {
-         g_assert(throttle_enabled(&cfg));
+     PCIDevice *pci_dev;
-     }
+     Error *unplug_blocker;
-     for (i = 0; i < BUCKETS_COUNT; i++) {
++
-         throttle_config_init(&cfg);
++    int vfu_poll_fd;
-         set_cfg_value(false, i, -150);
+ };
--        g_assert(!throttle_enabled(&cfg));
-+        g_assert(!throttle_is_valid(&cfg, NULL));
+ static void vfu_object_init_ctx(VfuObject *o, Error **errp);
@@ -XXX,XX +XXX,XX @@ static void vfu_object_set_device(Object *obj, const char *str, Error **errp)
      vfu_object_init_ctx(o, errp);
  }
 +static void vfu_object_ctx_run(void *opaque)
 +{
 +    VfuObject *o = opaque;
 +    const char *vfu_id;
 +    char *vfu_path, *pci_dev_path;
 +    int ret = -1;
 +
 +    while (ret != 0) {
 +        ret = vfu_run_ctx(o->vfu_ctx);
 +        if (ret < 0) {
 +            if (errno == EINTR) {
 +                continue;
 +            } else if (errno == ENOTCONN) {
 +                vfu_id = object_get_canonical_path_component(OBJECT(o));
 +                vfu_path = object_get_canonical_path(OBJECT(o));
 +                g_assert(o->pci_dev);
 +                pci_dev_path = object_get_canonical_path(OBJECT(o->pci_dev));
 +                 /* o->device is a required property and is non-NULL here */
 +                g_assert(o->device);
 +                qapi_event_send_vfu_client_hangup(vfu_id, vfu_path,
 +                                                  o->device, pci_dev_path);
 +                qemu_set_fd_handler(o->vfu_poll_fd, NULL, NULL, NULL);
 +                o->vfu_poll_fd = -1;
 +                object_unparent(OBJECT(o));
 +                g_free(vfu_path);
 +                g_free(pci_dev_path);
 +                break;
 +            } else {
 +                VFU_OBJECT_ERROR(o, "vfu: Failed to run device %s - %s",
 +                                 o->device, strerror(errno));
 +                break;
 +            }
 +        }
 +    }
 +}
 +
 +static void vfu_object_attach_ctx(void *opaque)
 +{
 +    VfuObject *o = opaque;
 +    GPollFD pfds[1];
 +    int ret;
 +
 +    qemu_set_fd_handler(o->vfu_poll_fd, NULL, NULL, NULL);
 +
 +    pfds[0].fd = o->vfu_poll_fd;
 +    pfds[0].events = G_IO_IN | G_IO_HUP | G_IO_ERR;
 +
 +retry_attach:
 +    ret = vfu_attach_ctx(o->vfu_ctx);
 +    if (ret < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
 +        /**
 +         * vfu_object_attach_ctx can block QEMU's main loop
 +         * during attach - the monitor and other IO
 +         * could be unresponsive during this time.
 +         */
 +        (void)qemu_poll_ns(pfds, 1, 500 * (int64_t)SCALE_MS);
 +        goto retry_attach;
 +    } else if (ret < 0) {
 +        VFU_OBJECT_ERROR(o, "vfu: Failed to attach device %s to context - %s",
 +                         o->device, strerror(errno));
 +        return;
 +    }
 +
 +    o->vfu_poll_fd = vfu_get_poll_fd(o->vfu_ctx);
 +    if (o->vfu_poll_fd < 0) {
 +        VFU_OBJECT_ERROR(o, "vfu: Failed to get poll fd %s", o->device);
 +        return;
 +    }
 +
 +    qemu_set_fd_handler(o->vfu_poll_fd, vfu_object_ctx_run, NULL, o);
 +}
 +
  /*
   * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
   * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_machine_done(Notifier *notifier, void *data)
      }
  }
-diff --git a/util/throttle.c b/util/throttle.c
++/**
-index XXXXXXX..XXXXXXX 100644
++ * vfu_object_init_ctx: Create and initialize libvfio-user context. Add
---- a/util/throttle.c
++ *     an unplug blocker for the associated PCI device. Setup a FD handler
-+++ b/util/throttle.c
++ *     to process incoming messages in the context's socket.
-@@ -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
++ *     The socket and device properties are mandatory, and this function
-          * from the guest, otherwise every other request will be throttled
++ *     will not create the context without them - the setters for these
-          * and performance will suffer considerably. */
++ *     properties should call this function when the property is set. The
--        bucket_size = bkt->avg / 10;
++ *     machine should also be ready when this function is invoked - it is
-+        bucket_size = (double) bkt->avg / 10;
++ *     because QEMU objects are initialized before devices, and the
-         burst_bucket_size = 0;
++ *     associated PCI device wouldn't be available at the object
-     } else {
++ *     initialization time. Until these conditions are satisfied, this
-         /* If we have a burst limit then we have to wait until all I/O
++ *     function would return early without performing any task.
-          * at burst rate has finished before throttling to bkt->avg */
++ */
-         bucket_size = bkt->max * bkt->burst_length;
+ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
--        burst_bucket_size = bkt->max / 10;
+ {
-+        burst_bucket_size = (double) bkt->max / 10;
+     ERRP_GUARD();
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
          return;
      }
-     /* If the main bucket is full then we have to wait */
+-    o->vfu_ctx = vfu_create_ctx(VFU_TRANS_SOCK, o->socket->u.q_unix.path, 0,
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
++    o->vfu_ctx = vfu_create_ctx(VFU_TRANS_SOCK, o->socket->u.q_unix.path,
++                                LIBVFIO_USER_FLAG_ATTACH_NB,
-     for (i = 0; i < BUCKETS_COUNT; i++) {
+                                 o, VFU_DEV_TYPE_PCI);
-         LeakyBucket *bkt = &cfg->buckets[i];
+     if (o->vfu_ctx == NULL) {
--        if (bkt->avg < 0 || bkt->max < 0 ||
+         error_setg(errp, "vfu: Failed to create context - %s", strerror(errno));
--            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
+@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
-+        if (bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
+                TYPE_VFU_OBJECT, o->device);
-             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
+     qdev_add_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
-                        THROTTLE_VALUE_MAX);
-             return false;
++    ret = vfu_realize_ctx(o->vfu_ctx);
 +    if (ret < 0) {
 +        error_setg(errp, "vfu: Failed to realize device %s- %s",
 +                   o->device, strerror(errno));
 +        goto fail;
 +    }
 +
 +    o->vfu_poll_fd = vfu_get_poll_fd(o->vfu_ctx);
 +    if (o->vfu_poll_fd < 0) {
 +        error_setg(errp, "vfu: Failed to get poll fd %s", o->device);
 +        goto fail;
 +    }
 +
 +    qemu_set_fd_handler(o->vfu_poll_fd, vfu_object_attach_ctx, NULL, o);
 +
      return;
  fail:
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init(Object *obj)
          qemu_add_machine_init_done_notifier(&o->machine_done);
      }
 +    o->vfu_poll_fd = -1;
  }
  static void vfu_object_finalize(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
      o->socket = NULL;
 +    if (o->vfu_poll_fd != -1) {
 +        qemu_set_fd_handler(o->vfu_poll_fd, NULL, NULL, NULL);
 +        o->vfu_poll_fd = -1;
 +    }
 +
      if (o->vfu_ctx) {
          vfu_destroy_ctx(o->vfu_ctx);
          o->vfu_ctx = NULL;
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 03/15] throttle: Update the throttle_fix_bucket() documentation
+[PULL 11/18] vfio-user: handle PCI config space accesses
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-The way the throttling algorithm works is that requests start being
+Define and register handlers for PCI config space accesses
 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
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-throttling requests immediately. The problem with keeping the
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
-threshold at 0 is that it only allows one request at a time, and as
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
-soon as there's a bit of I/O from the guest every other request will
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-be throttled and performance will suffer considerably. That can even
+Message-id: be9d2ccf9b1d24e50dcd9c23404dbf284142cec7.1655151679.git.jag.raman@oracle.com
 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 +++--------
+ hw/remote/vfio-user-obj.c | 51 +++++++++++++++++++++++++++++++++++++++
-file changed, 3 insertions(+), 8 deletions(-)
+ hw/remote/trace-events    |  2 ++
 files changed, 53 insertions(+)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/hw/remote/vfio-user-obj.c
-+++ b/util/throttle.c
++++ b/hw/remote/vfio-user-obj.c
-@@ -XXX,XX +XXX,XX @@ static void throttle_fix_bucket(LeakyBucket *bkt)
+@@ -XXX,XX +XXX,XX @@
-     /* zero bucket level */
+ #include "qapi/qapi-events-misc.h"
-     bkt->level = bkt->burst_level = 0;
+ #include "qemu/notify.h"
+ #include "qemu/thread.h"
--    /* The following is done to cope with the Linux CFQ block scheduler
++#include "qemu/main-loop.h"
--     * which regroup reads and writes by block of 100ms in the guest.
+ #include "sysemu/sysemu.h"
--     * When they are two process one making reads and one making writes cfq
+ #include "libvfio-user.h"
--     * make a pattern looking like the following:
+ #include "hw/qdev-core.h"
--     * WWWWWWWWWWWRRRRRRRRRRRRRRWWWWWWWWWWWWWwRRRRRRRRRRRRRRRRR
+@@ -XXX,XX +XXX,XX @@ retry_attach:
--     * Having a max burst value of 100ms of the average will help smooth the
+     qemu_set_fd_handler(o->vfu_poll_fd, vfu_object_ctx_run, NULL, o);
--     * throttling
+ }
--     */
-+    /* If bkt->max is 0 we still want to allow short bursts of I/O
++static ssize_t vfu_object_cfg_access(vfu_ctx_t *vfu_ctx, char * const buf,
-+     * from the guest, otherwise every other request will be throttled
++                                     size_t count, loff_t offset,
-+     * and performance will suffer considerably. */
++                                     const bool is_write)
-     min = bkt->avg / 10;
++{
-     if (bkt->avg && !bkt->max) {
++    VfuObject *o = vfu_get_private(vfu_ctx);
-         bkt->max = min;
++    uint32_t pci_access_width = sizeof(uint32_t);
 +    size_t bytes = count;
 +    uint32_t val = 0;
 +    char *ptr = buf;
 +    int len;
 +
 +    /*
 +     * Writes to the BAR registers would trigger an update to the
 +     * global Memory and IO AddressSpaces. But the remote device
 +     * never uses the global AddressSpaces, therefore overlapping
 +     * memory regions are not a problem
 +     */
 +    while (bytes > 0) {
 +        len = (bytes > pci_access_width) ? pci_access_width : bytes;
 +        if (is_write) {
 +            memcpy(&val, ptr, len);
 +            pci_host_config_write_common(o->pci_dev, offset,
 +                                         pci_config_size(o->pci_dev),
 +                                         val, len);
 +            trace_vfu_cfg_write(offset, val);
 +        } else {
 +            val = pci_host_config_read_common(o->pci_dev, offset,
 +                                              pci_config_size(o->pci_dev), len);
 +            memcpy(ptr, &val, len);
 +            trace_vfu_cfg_read(offset, val);
 +        }
 +        offset += len;
 +        ptr += len;
 +        bytes -= len;
 +    }
 +
 +    return count;
 +}
 +
  /*
   * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
   * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
                 TYPE_VFU_OBJECT, o->device);
      qdev_add_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
 +    ret = vfu_setup_region(o->vfu_ctx, VFU_PCI_DEV_CFG_REGION_IDX,
 +                           pci_config_size(o->pci_dev), &vfu_object_cfg_access,
 +                           VFU_REGION_FLAG_RW | VFU_REGION_FLAG_ALWAYS_CB,
 +                           NULL, 0, -1, 0);
 +    if (ret < 0) {
 +        error_setg(errp,
 +                   "vfu: Failed to setup config space handlers for %s- %s",
 +                   o->device, strerror(errno));
 +        goto fail;
 +    }
 +
      ret = vfu_realize_ctx(o->vfu_ctx);
      if (ret < 0) {
          error_setg(errp, "vfu: Failed to realize device %s- %s",
 diff --git a/hw/remote/trace-events b/hw/remote/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/trace-events
 +++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@ mpqemu_recv_io_error(int cmd, int size, int nfds) "failed to receive %d size %d,
  # vfio-user-obj.c
  vfu_prop(const char *prop, const char *val) "vfu: setting %s as %s"
 +vfu_cfg_read(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u -> 0x%x"
 +vfu_cfg_write(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u <- 0x%x"
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 02/15] throttle: Fix wrong variable name in the header documentation
+[PULL 12/18] vfio-user: IOMMU support for remote device
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-The level of the burst bucket is stored in bkt.burst_level, not
+Assign separate address space for each device in the remote processes.
-bkt.burst_length.
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
-Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
-Message-id: 49aab2711d02f285567f3b3b13a113847af33812.1503580370.git.berto@igalia.com
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: afe0b0a97582cdad42b5b25636a29c523265a10a.1655151679.git.jag.raman@oracle.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/throttle.h | 2 +-
+ MAINTAINERS               |   2 +
-file changed, 1 insertion(+), 1 deletion(-)
+ include/hw/remote/iommu.h |  40 ++++++++++++
+ hw/remote/iommu.c         | 131 ++++++++++++++++++++++++++++++++++++++
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+ hw/remote/machine.c       |  13 +++-
  hw/remote/meson.build     |   1 +
 files changed, 186 insertions(+), 1 deletion(-)
  create mode 100644 include/hw/remote/iommu.h
  create mode 100644 hw/remote/iommu.c
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/MAINTAINERS
-+++ b/include/qemu/throttle.h
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ F: hw/remote/iohub.c
-  * - The bkt.avg rate does not apply until the bucket is full,
+ F: include/hw/remote/iohub.h
-  *   allowing the user to do bursts until then. The I/O limit during
+ F: subprojects/libvfio-user
-  *   bursts is bkt.max. To enforce this limit we keep an additional
+ F: hw/remote/vfio-user-obj.c
-- *   bucket in bkt.burst_length that leaks at a rate of bkt.max units
++F: hw/remote/iommu.c
-+ *   bucket in bkt.burst_level that leaks at a rate of bkt.max units
++F: include/hw/remote/iommu.h
-  *   per second.
-  *
+ EBPF:
-  * - Because of all of the above, the user can perform I/O at a
+ M: Jason Wang <jasowang@redhat.com>
 diff --git a/include/hw/remote/iommu.h b/include/hw/remote/iommu.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/include/hw/remote/iommu.h
@@ -XXX,XX +XXX,XX @@
 +/**
 + * Copyright © 2022 Oracle and/or its affiliates.
 + *
 + * 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 REMOTE_IOMMU_H
 +#define REMOTE_IOMMU_H
 +
 +#include "hw/pci/pci_bus.h"
 +#include "hw/pci/pci.h"
 +
 +#ifndef INT2VOIDP
 +#define INT2VOIDP(i) (void *)(uintptr_t)(i)
 +#endif
 +
 +typedef struct RemoteIommuElem {
 +    MemoryRegion *mr;
 +
 +    AddressSpace as;
 +} RemoteIommuElem;
 +
 +#define TYPE_REMOTE_IOMMU "x-remote-iommu"
 +OBJECT_DECLARE_SIMPLE_TYPE(RemoteIommu, REMOTE_IOMMU)
 +
 +struct RemoteIommu {
 +    Object parent;
 +
 +    GHashTable *elem_by_devfn;
 +
 +    QemuMutex lock;
 +};
 +
 +void remote_iommu_setup(PCIBus *pci_bus);
 +
 +void remote_iommu_unplug_dev(PCIDevice *pci_dev);
 +
 +#endif
 diff --git a/hw/remote/iommu.c b/hw/remote/iommu.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/hw/remote/iommu.c
@@ -XXX,XX +XXX,XX @@
 +/**
 + * IOMMU for remote device
 + *
 + * Copyright © 2022 Oracle and/or its affiliates.
 + *
 + * 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 "hw/remote/iommu.h"
 +#include "hw/pci/pci_bus.h"
 +#include "hw/pci/pci.h"
 +#include "exec/memory.h"
 +#include "exec/address-spaces.h"
 +#include "trace.h"
 +
 +/**
 + * IOMMU for TYPE_REMOTE_MACHINE - manages DMA address space isolation
 + *     for remote machine. It is used by TYPE_VFIO_USER_SERVER.
 + *
 + * - Each TYPE_VFIO_USER_SERVER instance handles one PCIDevice on a PCIBus.
 + *   There is one RemoteIommu per PCIBus, so the RemoteIommu tracks multiple
 + *   PCIDevices by maintaining a ->elem_by_devfn mapping.
 + *
 + * - memory_region_init_iommu() is not used because vfio-user MemoryRegions
 + *   will be added to the elem->mr container instead. This is more natural
 + *   than implementing the IOMMUMemoryRegionClass APIs since vfio-user
 + *   provides something that is close to a full-fledged MemoryRegion and
 + *   not like an IOMMU mapping.
 + *
 + * - When a device is hot unplugged, the elem->mr reference is dropped so
 + *   all vfio-user MemoryRegions associated with this vfio-user server are
 + *   destroyed.
 + */
 +
 +static AddressSpace *remote_iommu_find_add_as(PCIBus *pci_bus,
 +                                              void *opaque, int devfn)
 +{
 +    RemoteIommu *iommu = opaque;
 +    RemoteIommuElem *elem = NULL;
 +
 +    qemu_mutex_lock(&iommu->lock);
 +
 +    elem = g_hash_table_lookup(iommu->elem_by_devfn, INT2VOIDP(devfn));
 +
 +    if (!elem) {
 +        elem = g_malloc0(sizeof(RemoteIommuElem));
 +        g_hash_table_insert(iommu->elem_by_devfn, INT2VOIDP(devfn), elem);
 +    }
 +
 +    if (!elem->mr) {
 +        elem->mr = MEMORY_REGION(object_new(TYPE_MEMORY_REGION));
 +        memory_region_set_size(elem->mr, UINT64_MAX);
 +        address_space_init(&elem->as, elem->mr, NULL);
 +    }
 +
 +    qemu_mutex_unlock(&iommu->lock);
 +
 +    return &elem->as;
 +}
 +
 +void remote_iommu_unplug_dev(PCIDevice *pci_dev)
 +{
 +    AddressSpace *as = pci_device_iommu_address_space(pci_dev);
 +    RemoteIommuElem *elem = NULL;
 +
 +    if (as == &address_space_memory) {
 +        return;
 +    }
 +
 +    elem = container_of(as, RemoteIommuElem, as);
 +
 +    address_space_destroy(&elem->as);
 +
 +    object_unref(elem->mr);
 +
 +    elem->mr = NULL;
 +}
 +
 +static void remote_iommu_init(Object *obj)
 +{
 +    RemoteIommu *iommu = REMOTE_IOMMU(obj);
 +
 +    iommu->elem_by_devfn = g_hash_table_new_full(NULL, NULL, NULL, g_free);
 +
 +    qemu_mutex_init(&iommu->lock);
 +}
 +
 +static void remote_iommu_finalize(Object *obj)
 +{
 +    RemoteIommu *iommu = REMOTE_IOMMU(obj);
 +
 +    qemu_mutex_destroy(&iommu->lock);
 +
 +    g_hash_table_destroy(iommu->elem_by_devfn);
 +
 +    iommu->elem_by_devfn = NULL;
 +}
 +
 +void remote_iommu_setup(PCIBus *pci_bus)
 +{
 +    RemoteIommu *iommu = NULL;
 +
 +    g_assert(pci_bus);
 +
 +    iommu = REMOTE_IOMMU(object_new(TYPE_REMOTE_IOMMU));
 +
 +    pci_setup_iommu(pci_bus, remote_iommu_find_add_as, iommu);
 +
 +    object_property_add_child(OBJECT(pci_bus), "remote-iommu", OBJECT(iommu));
 +
 +    object_unref(OBJECT(iommu));
 +}
 +
 +static const TypeInfo remote_iommu_info = {
 +    .name = TYPE_REMOTE_IOMMU,
 +    .parent = TYPE_OBJECT,
 +    .instance_size = sizeof(RemoteIommu),
 +    .instance_init = remote_iommu_init,
 +    .instance_finalize = remote_iommu_finalize,
 +};
 +
 +static void remote_iommu_register_types(void)
 +{
 +    type_register_static(&remote_iommu_info);
 +}
 +
 +type_init(remote_iommu_register_types)
 diff --git a/hw/remote/machine.c b/hw/remote/machine.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/machine.c
 +++ b/hw/remote/machine.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/error.h"
  #include "hw/pci/pci_host.h"
  #include "hw/remote/iohub.h"
 +#include "hw/remote/iommu.h"
  #include "hw/qdev-core.h"
  static void remote_machine_init(MachineState *machine)
@@ -XXX,XX +XXX,XX @@ static void remote_machine_instance_init(Object *obj)
      s->auto_shutdown = true;
  }
 +static void remote_machine_dev_unplug_cb(HotplugHandler *hotplug_dev,
 +                                         DeviceState *dev, Error **errp)
 +{
 +    qdev_unrealize(dev);
 +
 +    if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
 +        remote_iommu_unplug_dev(PCI_DEVICE(dev));
 +    }
 +}
 +
  static void remote_machine_class_init(ObjectClass *oc, void *data)
  {
      MachineClass *mc = MACHINE_CLASS(oc);
@@ -XXX,XX +XXX,XX @@ static void remote_machine_class_init(ObjectClass *oc, void *data)
      mc->init = remote_machine_init;
      mc->desc = "Experimental remote machine";
 -    hc->unplug = qdev_simple_device_unplug_cb;
 +    hc->unplug = remote_machine_dev_unplug_cb;
      object_class_property_add_bool(oc, "vfio-user",
                                     remote_machine_get_vfio_user,
 diff --git a/hw/remote/meson.build b/hw/remote/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/meson.build
 +++ b/hw/remote/meson.build
@@ -XXX,XX +XXX,XX @@ remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('message.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('remote-obj.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('proxy.c'))
  remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('iohub.c'))
 +remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('iommu.c'))
  remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: files('vfio-user-obj.c'))
  remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: libvfio_user_dep)
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 04/15] throttle: Make throttle_is_valid() a bit less verbose
+[PULL 13/18] vfio-user: handle DMA mappings
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-Use a pointer to the bucket instead of repeating cfg->buckets[i] all
+Define and register callbacks to manage the RAM regions used for
-the time. This makes the code more concise and will help us expand the
+device DMA
 checks later and save a few line breaks.
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-Message-id: 763ffc40a26b17d54cf93f5a999e4656049fcf0c.1503580370.git.berto@igalia.com
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
 Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: faacbcd45c4d02c591f0dbfdc19041fbb3eae7eb.1655151679.git.jag.raman@oracle.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- util/throttle.c | 15 +++++++--------
+ hw/remote/machine.c       |  5 ++++
-file changed, 7 insertions(+), 8 deletions(-)
+ hw/remote/vfio-user-obj.c | 55 +++++++++++++++++++++++++++++++++++++++
  hw/remote/trace-events    |  2 ++
 files changed, 62 insertions(+)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/hw/remote/machine.c b/hw/remote/machine.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/hw/remote/machine.c
-+++ b/util/throttle.c
++++ b/hw/remote/machine.c
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
+@@ -XXX,XX +XXX,XX @@
  #include "hw/remote/iohub.h"
  #include "hw/remote/iommu.h"
  #include "hw/qdev-core.h"
 +#include "hw/remote/iommu.h"
  static void remote_machine_init(MachineState *machine)
  {
@@ -XXX,XX +XXX,XX @@ static void remote_machine_init(MachineState *machine)
      pci_host = PCI_HOST_BRIDGE(rem_host);
 +    if (s->vfio_user) {
 +        remote_iommu_setup(pci_host->bus);
 +    }
 +
      remote_iohub_init(&s->iohub);
      pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, remote_iohub_map_irq,
 diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/vfio-user-obj.c
 +++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@ static ssize_t vfu_object_cfg_access(vfu_ctx_t *vfu_ctx, char * const buf,
      return count;
  }
 +static void dma_register(vfu_ctx_t *vfu_ctx, vfu_dma_info_t *info)
 +{
 +    VfuObject *o = vfu_get_private(vfu_ctx);
 +    AddressSpace *dma_as = NULL;
 +    MemoryRegion *subregion = NULL;
 +    g_autofree char *name = NULL;
 +    struct iovec *iov = &info->iova;
 +
 +    if (!info->vaddr) {
 +        return;
 +    }
 +
 +    name = g_strdup_printf("mem-%s-%"PRIx64"", o->device,
 +                           (uint64_t)info->vaddr);
 +
 +    subregion = g_new0(MemoryRegion, 1);
 +
 +    memory_region_init_ram_ptr(subregion, NULL, name,
 +                               iov->iov_len, info->vaddr);
 +
 +    dma_as = pci_device_iommu_address_space(o->pci_dev);
 +
 +    memory_region_add_subregion(dma_as->root, (hwaddr)iov->iov_base, subregion);
 +
 +    trace_vfu_dma_register((uint64_t)iov->iov_base, iov->iov_len);
 +}
 +
 +static void dma_unregister(vfu_ctx_t *vfu_ctx, vfu_dma_info_t *info)
 +{
 +    VfuObject *o = vfu_get_private(vfu_ctx);
 +    AddressSpace *dma_as = NULL;
 +    MemoryRegion *mr = NULL;
 +    ram_addr_t offset;
 +
 +    mr = memory_region_from_host(info->vaddr, &offset);
 +    if (!mr) {
 +        return;
 +    }
 +
 +    dma_as = pci_device_iommu_address_space(o->pci_dev);
 +
 +    memory_region_del_subregion(dma_as->root, mr);
 +
 +    object_unparent((OBJECT(mr)));
 +
 +    trace_vfu_dma_unregister((uint64_t)info->iova.iov_base);
 +}
 +
  /*
   * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
   * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
          goto fail;
      }
-     for (i = 0; i < BUCKETS_COUNT; i++) {
++    ret = vfu_setup_device_dma(o->vfu_ctx, &dma_register, &dma_unregister);
--        if (cfg->buckets[i].avg < 0 ||
++    if (ret < 0) {
--            cfg->buckets[i].max < 0 ||
++        error_setg(errp, "vfu: Failed to setup DMA handlers for %s",
--            cfg->buckets[i].avg > THROTTLE_VALUE_MAX ||
++                   o->device);
--            cfg->buckets[i].max > THROTTLE_VALUE_MAX) {
++        goto fail;
-+        LeakyBucket *bkt = &cfg->buckets[i];
++    }
-+        if (bkt->avg < 0 || bkt->max < 0 ||
++
-+            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
+     ret = vfu_realize_ctx(o->vfu_ctx);
-             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
+     if (ret < 0) {
-                        THROTTLE_VALUE_MAX);
+         error_setg(errp, "vfu: Failed to realize device %s- %s",
-             return false;
+diff --git a/hw/remote/trace-events b/hw/remote/trace-events
-         }
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/remote/trace-events
--        if (!cfg->buckets[i].burst_length) {
++++ b/hw/remote/trace-events
-+        if (!bkt->burst_length) {
+@@ -XXX,XX +XXX,XX @@ mpqemu_recv_io_error(int cmd, int size, int nfds) "failed to receive %d size %d,
-             error_setg(errp, "the burst length cannot be 0");
+ vfu_prop(const char *prop, const char *val) "vfu: setting %s as %s"
-             return false;
+ vfu_cfg_read(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u -> 0x%x"
-         }
+ vfu_cfg_write(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u <- 0x%x"
++vfu_dma_register(uint64_t gpa, size_t len) "vfu: registering GPA 0x%"PRIx64", %zu bytes"
--        if (cfg->buckets[i].burst_length > 1 && !cfg->buckets[i].max) {
++vfu_dma_unregister(uint64_t gpa) "vfu: unregistering GPA 0x%"PRIx64""
 +        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;
          }
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 08/15] throttle: Test the valid range of config values
+[PULL 14/18] vfio-user: handle PCI BAR accesses
-From: Alberto Garcia <berto@igalia.com>
+From: Jagannathan Raman <jag.raman@oracle.com>
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Determine the BARs used by the PCI device and register handlers to
-Message-id: a57dd6274e1b6dc9c28769fec4c7ea543be5c5e3.1503580370.git.berto@igalia.com
+manage the access to the same.
 Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
 Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
 Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 3373e10b5be5f42846f0632d4382466e1698c505.1655151679.git.jag.raman@oracle.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/test-throttle.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ include/exec/memory.h           |   3 +
-file changed, 77 insertions(+)
+ hw/remote/vfio-user-obj.c       | 190 ++++++++++++++++++++++++++++++++
  softmmu/physmem.c               |   4 +-
  tests/qtest/fuzz/generic_fuzz.c |   9 +-
  hw/remote/trace-events          |   3 +
 files changed, 203 insertions(+), 6 deletions(-)
-diff --git a/tests/test-throttle.c b/tests/test-throttle.c
+diff --git a/include/exec/memory.h b/include/exec/memory.h
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-throttle.c
+--- a/include/exec/memory.h
-+++ b/tests/test-throttle.c
++++ b/include/exec/memory.h
-@@ -XXX,XX +XXX,XX @@ static void test_is_valid(void)
+@@ -XXX,XX +XXX,XX @@ MemTxResult address_space_write_cached_slow(MemoryRegionCache *cache,
-     test_is_valid_for_value(1, true);
+                                             hwaddr addr, const void *buf,
                                              hwaddr len);
 +int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr);
 +bool prepare_mmio_access(MemoryRegion *mr);
 +
  static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
  {
      if (is_write) {
 diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/vfio-user-obj.c
 +++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
  #include "hw/qdev-core.h"
  #include "hw/pci/pci.h"
  #include "qemu/timer.h"
 +#include "exec/memory.h"
  #define TYPE_VFU_OBJECT "x-vfio-user-server"
  OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
@@ -XXX,XX +XXX,XX @@ static void dma_unregister(vfu_ctx_t *vfu_ctx, vfu_dma_info_t *info)
      trace_vfu_dma_unregister((uint64_t)info->iova.iov_base);
  }
-+static void test_ranges(void)
++static int vfu_object_mr_rw(MemoryRegion *mr, uint8_t *buf, hwaddr offset,
 +                            hwaddr size, const bool is_write)
 +{
++    uint8_t *ptr = buf;
++    bool release_lock = false;
++    uint8_t *ram_ptr = NULL;
++    MemTxResult result;
++    int access_size;
++    uint64_t val;
++
++    if (memory_access_is_direct(mr, is_write)) {
++        /**
++         * Some devices expose a PCI expansion ROM, which could be buffer
++         * based as compared to other regions which are primarily based on
++         * MemoryRegionOps. memory_region_find() would already check
++         * for buffer overflow, we don't need to repeat it here.
++         */
++        ram_ptr = memory_region_get_ram_ptr(mr);
++
++        if (is_write) {
++            memcpy((ram_ptr + offset), buf, size);
++        } else {
++            memcpy(buf, (ram_ptr + offset), size);
++        }
++
++        return 0;
++    }
++
++    while (size) {
++        /**
++         * The read/write logic used below is similar to the ones in
++         * flatview_read/write_continue()
++         */
++        release_lock = prepare_mmio_access(mr);
++
++        access_size = memory_access_size(mr, size, offset);
++
++        if (is_write) {
++            val = ldn_he_p(ptr, access_size);
++
++            result = memory_region_dispatch_write(mr, offset, val,
++                                                  size_memop(access_size),
++                                                  MEMTXATTRS_UNSPECIFIED);
++        } else {
++            result = memory_region_dispatch_read(mr, offset, &val,
++                                                 size_memop(access_size),
++                                                 MEMTXATTRS_UNSPECIFIED);
++
++            stn_he_p(ptr, access_size, val);
++        }
++
++        if (release_lock) {
++            qemu_mutex_unlock_iothread();
++            release_lock = false;
++        }
++
++        if (result != MEMTX_OK) {
++            return -1;
++        }
++
++        size -= access_size;
++        ptr += access_size;
++        offset += access_size;
++    }
++
++    return 0;
++}
++
++static size_t vfu_object_bar_rw(PCIDevice *pci_dev, int pci_bar,
++                                hwaddr bar_offset, char * const buf,
++                                hwaddr len, const bool is_write)
++{
++    MemoryRegionSection section = { 0 };
++    uint8_t *ptr = (uint8_t *)buf;
++    MemoryRegion *section_mr = NULL;
++    uint64_t section_size;
++    hwaddr section_offset;
++    hwaddr size = 0;
++
++    while (len) {
++        section = memory_region_find(pci_dev->io_regions[pci_bar].memory,
++                                     bar_offset, len);
++
++        if (!section.mr) {
++            warn_report("vfu: invalid address 0x%"PRIx64"", bar_offset);
++            return size;
++        }
++
++        section_mr = section.mr;
++        section_offset = section.offset_within_region;
++        section_size = int128_get64(section.size);
++
++        if (is_write && section_mr->readonly) {
++            warn_report("vfu: attempting to write to readonly region in "
++                        "bar %d - [0x%"PRIx64" - 0x%"PRIx64"]",
++                        pci_bar, bar_offset,
++                        (bar_offset + section_size));
++            memory_region_unref(section_mr);
++            return size;
++        }
++
++        if (vfu_object_mr_rw(section_mr, ptr, section_offset,
++                             section_size, is_write)) {
++            warn_report("vfu: failed to %s "
++                        "[0x%"PRIx64" - 0x%"PRIx64"] in bar %d",
++                        is_write ? "write to" : "read from", bar_offset,
++                        (bar_offset + section_size), pci_bar);
++            memory_region_unref(section_mr);
++            return size;
++        }
++
++        size += section_size;
++        bar_offset += section_size;
++        ptr += section_size;
++        len -= section_size;
++
++        memory_region_unref(section_mr);
++    }
++
++    return size;
++}
++
++/**
++ * VFU_OBJECT_BAR_HANDLER - macro for defining handlers for PCI BARs.
++ *
++ * To create handler for BAR number 2, VFU_OBJECT_BAR_HANDLER(2) would
++ * define vfu_object_bar2_handler
++ */
++#define VFU_OBJECT_BAR_HANDLER(BAR_NO)                                         \
++    static ssize_t vfu_object_bar##BAR_NO##_handler(vfu_ctx_t *vfu_ctx,        \
++                                        char * const buf, size_t count,        \
++                                        loff_t offset, const bool is_write)    \
++    {                                                                          \
++        VfuObject *o = vfu_get_private(vfu_ctx);                               \
++        PCIDevice *pci_dev = o->pci_dev;                                       \
++                                                                               \
++        return vfu_object_bar_rw(pci_dev, BAR_NO, offset,                      \
++                                 buf, count, is_write);                        \
++    }                                                                          \
++
++VFU_OBJECT_BAR_HANDLER(0)
++VFU_OBJECT_BAR_HANDLER(1)
++VFU_OBJECT_BAR_HANDLER(2)
++VFU_OBJECT_BAR_HANDLER(3)
++VFU_OBJECT_BAR_HANDLER(4)
++VFU_OBJECT_BAR_HANDLER(5)
++VFU_OBJECT_BAR_HANDLER(6)
++
++static vfu_region_access_cb_t *vfu_object_bar_handlers[PCI_NUM_REGIONS] = {
++    &vfu_object_bar0_handler,
++    &vfu_object_bar1_handler,
++    &vfu_object_bar2_handler,
++    &vfu_object_bar3_handler,
++    &vfu_object_bar4_handler,
++    &vfu_object_bar5_handler,
++    &vfu_object_bar6_handler,
++};
++
++/**
++ * vfu_object_register_bars - Identify active BAR regions of pdev and setup
++ *                            callbacks to handle read/write accesses
++ */
++static void vfu_object_register_bars(vfu_ctx_t *vfu_ctx, PCIDevice *pdev)
++{
++    int flags = VFU_REGION_FLAG_RW;
 +    int i;
 +
-+    for (i = 0; i < BUCKETS_COUNT; i++) {
++    for (i = 0; i < PCI_NUM_REGIONS; i++) {
-+        LeakyBucket *b = &cfg.buckets[i];
++        if (!pdev->io_regions[i].size) {
-+        throttle_config_init(&cfg);
++            continue;
-+
++        }
-+        /* avg = 0 means throttling is disabled, but the config is valid */
++
-+        b->avg = 0;
++        if ((i == VFU_PCI_DEV_ROM_REGION_IDX) ||
-+        g_assert(throttle_is_valid(&cfg, NULL));
++            pdev->io_regions[i].memory->readonly) {
-+        g_assert(!throttle_enabled(&cfg));
++            flags &= ~VFU_REGION_FLAG_WRITE;
-+
++        }
-+        /* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
++
-+        b->avg = 1;
++        vfu_setup_region(vfu_ctx, VFU_PCI_DEV_BAR0_REGION_IDX + i,
-+        g_assert(throttle_is_valid(&cfg, NULL));
++                         (size_t)pdev->io_regions[i].size,
-+
++                         vfu_object_bar_handlers[i],
-+        b->avg = THROTTLE_VALUE_MAX;
++                         flags, NULL, 0, -1, 0);
-+        g_assert(throttle_is_valid(&cfg, NULL));
++
-+
++        trace_vfu_bar_register(i, pdev->io_regions[i].addr,
-+        b->avg = THROTTLE_VALUE_MAX;
++                               pdev->io_regions[i].size);
 +        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)
+ /*
   * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
   * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
          goto fail;
      }
 +    vfu_object_register_bars(o->vfu_ctx, o->pci_dev);
 +
      ret = vfu_realize_ctx(o->vfu_ctx);
      if (ret < 0) {
          error_setg(errp, "vfu: Failed to realize device %s- %s",
 diff --git a/softmmu/physmem.c b/softmmu/physmem.c
 index XXXXXXX..XXXXXXX 100644
 --- a/softmmu/physmem.c
 +++ b/softmmu/physmem.c
@@ -XXX,XX +XXX,XX @@ void memory_region_flush_rom_device(MemoryRegion *mr, hwaddr addr, hwaddr size)
      invalidate_and_set_dirty(mr, addr, size);
  }
 -static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
 +int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
  {
-     int i;
+     unsigned access_size_max = mr->ops->valid.max_access_size;
-@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-     g_test_add_func("/throttle/config/enabled",     test_enabled);
+@@ -XXX,XX +XXX,XX @@ static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
-     g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
+     return l;
-     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);
+-static bool prepare_mmio_access(MemoryRegion *mr)
-     g_test_add_func("/throttle/config/iops_size",
++bool prepare_mmio_access(MemoryRegion *mr)
-                     test_iops_size_is_missing_limit);
+ {
      bool release_lock = false;
 diff --git a/tests/qtest/fuzz/generic_fuzz.c b/tests/qtest/fuzz/generic_fuzz.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qtest/fuzz/generic_fuzz.c
 +++ b/tests/qtest/fuzz/generic_fuzz.c
@@ -XXX,XX +XXX,XX @@ static void *pattern_alloc(pattern p, size_t len)
      return buf;
  }
 -static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
 +static int fuzz_memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
  {
      unsigned access_size_max = mr->ops->valid.max_access_size;
@@ -XXX,XX +XXX,XX @@ void fuzz_dma_read_cb(size_t addr, size_t len, MemoryRegion *mr)
          /*
           *  If mr1 isn't RAM, address_space_translate doesn't update l. Use
 -         *  memory_access_size to identify the number of bytes that it is safe
 -         *  to write without accidentally writing to another MemoryRegion.
 +         *  fuzz_memory_access_size to identify the number of bytes that it
 +         *  is safe to write without accidentally writing to another
 +         *  MemoryRegion.
           */
          if (!memory_region_is_ram(mr1)) {
 -            l = memory_access_size(mr1, l, addr1);
 +            l = fuzz_memory_access_size(mr1, l, addr1);
          }
          if (memory_region_is_ram(mr1) ||
              memory_region_is_romd(mr1) ||
 diff --git a/hw/remote/trace-events b/hw/remote/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/remote/trace-events
 +++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@ vfu_cfg_read(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u -> 0x%x"
  vfu_cfg_write(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u <- 0x%x"
  vfu_dma_register(uint64_t gpa, size_t len) "vfu: registering GPA 0x%"PRIx64", %zu bytes"
  vfu_dma_unregister(uint64_t gpa) "vfu: unregistering GPA 0x%"PRIx64""
 +vfu_bar_register(int i, uint64_t addr, uint64_t size) "vfu: BAR %d: addr 0x%"PRIx64" size 0x%"PRIx64""
 +vfu_bar_rw_enter(const char *op, uint64_t addr) "vfu: %s request for BAR address 0x%"PRIx64""
 +vfu_bar_rw_exit(const char *op, uint64_t addr) "vfu: Finished %s of BAR address 0x%"PRIx64""
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 11/15] scripts: add argparse module for Python 2.6 compatibility
+[PULL 15/18] vfio-user: handle device interrupts
-The minimum Python version supported by QEMU is 2.6.  The argparse
+From: Jagannathan Raman <jag.raman@oracle.com>
 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.
+Forward remote device's interrupts to the guest
-Suggested-by: Daniel P. Berrange <berrange@redhat.com>
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
-Acked-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
-Message-id: 20170825155732.15665-2-stefanha@redhat.com
+Message-id: 9523479eaafe050677f4de2af5dd0df18c27cfd9.1655151679.git.jag.raman@oracle.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- COPYING.PYTHON      |  270 ++++++
+ MAINTAINERS                       |   1 +
- scripts/argparse.py | 2406 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ include/hw/pci/msi.h              |   1 +
-files changed, 2676 insertions(+)
+ include/hw/pci/msix.h             |   1 +
- create mode 100644 COPYING.PYTHON
+ include/hw/pci/pci.h              |  13 +++
- create mode 100644 scripts/argparse.py
+ include/hw/remote/vfio-user-obj.h |   6 ++
  hw/pci/msi.c                      |  49 +++++++--
  hw/pci/msix.c                     |  35 ++++++-
  hw/pci/pci.c                      |  13 +++
  hw/remote/machine.c               |  16 ++-
  hw/remote/vfio-user-obj.c         | 167 ++++++++++++++++++++++++++++++
  stubs/vfio-user-obj.c             |   6 ++
  hw/remote/trace-events            |   1 +
  stubs/meson.build                 |   1 +
 files changed, 298 insertions(+), 12 deletions(-)
  create mode 100644 include/hw/remote/vfio-user-obj.h
  create mode 100644 stubs/vfio-user-obj.c
-diff --git a/COPYING.PYTHON b/COPYING.PYTHON
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: hw/remote/iohub.c
  F: include/hw/remote/iohub.h
  F: subprojects/libvfio-user
  F: hw/remote/vfio-user-obj.c
 +F: include/hw/remote/vfio-user-obj.h
  F: hw/remote/iommu.c
  F: include/hw/remote/iommu.h
 diff --git a/include/hw/pci/msi.h b/include/hw/pci/msi.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/hw/pci/msi.h
 +++ b/include/hw/pci/msi.h
@@ -XXX,XX +XXX,XX @@ void msi_notify(PCIDevice *dev, unsigned int vector);
  void msi_send_message(PCIDevice *dev, MSIMessage msg);
  void msi_write_config(PCIDevice *dev, uint32_t addr, uint32_t val, int len);
  unsigned int msi_nr_vectors_allocated(const PCIDevice *dev);
 +void msi_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp);
  static inline bool msi_present(const PCIDevice *dev)
  {
 diff --git a/include/hw/pci/msix.h b/include/hw/pci/msix.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/hw/pci/msix.h
 +++ b/include/hw/pci/msix.h
@@ -XXX,XX +XXX,XX @@ void msix_clr_pending(PCIDevice *dev, int vector);
  int msix_vector_use(PCIDevice *dev, unsigned vector);
  void msix_vector_unuse(PCIDevice *dev, unsigned vector);
  void msix_unuse_all_vectors(PCIDevice *dev);
 +void msix_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp);
  void msix_notify(PCIDevice *dev, unsigned vector);
 diff --git a/include/hw/pci/pci.h b/include/hw/pci/pci.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/hw/pci/pci.h
 +++ b/include/hw/pci/pci.h
@@ -XXX,XX +XXX,XX @@ extern bool pci_available;
  #define PCI_SLOT(devfn)         (((devfn) >> 3) & 0x1f)
  #define PCI_FUNC(devfn)         ((devfn) & 0x07)
  #define PCI_BUILD_BDF(bus, devfn)     ((bus << 8) | (devfn))
 +#define PCI_BDF_TO_DEVFN(x)     ((x) & 0xff)
  #define PCI_BUS_MAX             256
  #define PCI_DEVFN_MAX           256
  #define PCI_SLOT_MAX            32
@@ -XXX,XX +XXX,XX @@ typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
                                  pcibus_t addr, pcibus_t size, int type);
  typedef void PCIUnregisterFunc(PCIDevice *pci_dev);
 +typedef void MSITriggerFunc(PCIDevice *dev, MSIMessage msg);
 +typedef MSIMessage MSIPrepareMessageFunc(PCIDevice *dev, unsigned vector);
 +typedef MSIMessage MSIxPrepareMessageFunc(PCIDevice *dev, unsigned vector);
 +
  typedef struct PCIIORegion {
      pcibus_t addr; /* current PCI mapping address. -1 means not mapped */
  #define PCI_BAR_UNMAPPED (~(pcibus_t)0)
@@ -XXX,XX +XXX,XX @@ struct PCIDevice {
      /* Space to store MSIX table & pending bit array */
      uint8_t *msix_table;
      uint8_t *msix_pba;
 +
 +    /* May be used by INTx or MSI during interrupt notification */
 +    void *irq_opaque;
 +
 +    MSITriggerFunc *msi_trigger;
 +    MSIPrepareMessageFunc *msi_prepare_message;
 +    MSIxPrepareMessageFunc *msix_prepare_message;
 +
      /* MemoryRegion container for msix exclusive BAR setup */
      MemoryRegion msix_exclusive_bar;
      /* Memory Regions for MSIX table and pending bit entries. */
 diff --git a/include/hw/remote/vfio-user-obj.h b/include/hw/remote/vfio-user-obj.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/COPYING.PYTHON
++++ b/include/hw/remote/vfio-user-obj.h
 @@ -XXX,XX +XXX,XX @@
-+A. HISTORY OF THE SOFTWARE
++#ifndef VFIO_USER_OBJ_H
-+==========================
++#define VFIO_USER_OBJ_H
 +
-+Python was created in the early 1990s by Guido van Rossum at Stichting
++void vfu_object_set_bus_irq(PCIBus *pci_bus);
-+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
++
-+as a successor of a language called ABC.  Guido remains Python's
++#endif
-+principal author, although it includes many contributions from others.
+diff --git a/hw/pci/msi.c b/hw/pci/msi.c
-+
+index XXXXXXX..XXXXXXX 100644
-+In 1995, Guido continued his work on Python at the Corporation for
+--- a/hw/pci/msi.c
-+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
++++ b/hw/pci/msi.c
-+in Reston, Virginia where he released several versions of the
+@@ -XXX,XX +XXX,XX @@ void msi_set_message(PCIDevice *dev, MSIMessage msg)
-+software.
+     pci_set_word(dev->config + msi_data_off(dev, msi64bit), msg.data);
-+
+ }
-+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
+-MSIMessage msi_get_message(PCIDevice *dev, unsigned int vector)
-+year, the PythonLabs team moved to Digital Creations (now Zope
++static MSIMessage msi_prepare_message(PCIDevice *dev, unsigned int vector)
-+Corporation, see http://www.zope.com).  In 2001, the Python Software
+ {
-+Foundation (PSF, see http://www.python.org/psf/) was formed, a
+     uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
-+non-profit organization created specifically to own Python-related
+     bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;
-+Intellectual Property.  Zope Corporation is a sponsoring member of
+@@ -XXX,XX +XXX,XX @@ MSIMessage msi_get_message(PCIDevice *dev, unsigned int vector)
-+the PSF.
+     return msg;
-+
+ }
-+All Python releases are Open Source (see http://www.opensource.org for
-+the Open Source Definition).  Historically, most, but not all, Python
++MSIMessage msi_get_message(PCIDevice *dev, unsigned int vector)
-+releases have also been GPL-compatible; the table below summarizes
++{
-+the various releases.
++    return dev->msi_prepare_message(dev, vector);
-+
++}
-+    Release         Derived     Year        Owner       GPL-
++
-+                    from                                compatible? (1)
+ bool msi_enabled(const PCIDevice *dev)
-+
+ {
-+    0.9.0 thru 1.2              1991-1995   CWI         yes
+     return msi_present(dev) &&
-+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+@@ -XXX,XX +XXX,XX @@ int msi_init(struct PCIDevice *dev, uint8_t offset,
-+    1.6             1.5.2       2000        CNRI        no
+xffffffff >> (PCI_MSI_VECTORS_MAX - nr_vectors));
-+    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
++    dev->msi_prepare_message = msi_prepare_message;
-+    2.0.1           2.0+1.6.1   2001        PSF         yes
++
-+    2.1.1           2.1+2.0.1   2001        PSF         yes
+     return 0;
-+    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
+@@ -XXX,XX +XXX,XX @@ void msi_uninit(struct PCIDevice *dev)
-+    2.2.1           2.2         2002        PSF         yes
+     cap_size = msi_cap_sizeof(flags);
-+    2.2.2           2.2.1       2002        PSF         yes
+     pci_del_capability(dev, PCI_CAP_ID_MSI, cap_size);
-+    2.2.3           2.2.2       2003        PSF         yes
+     dev->cap_present &= ~QEMU_PCI_CAP_MSI;
-+    2.3             2.2.2       2002-2003   PSF         yes
++    dev->msi_prepare_message = NULL;
-+    2.3.1           2.3         2002-2003   PSF         yes
-+    2.3.2           2.3.1       2002-2003   PSF         yes
+     MSI_DEV_PRINTF(dev, "uninit\n");
-+    2.3.3           2.3.2       2002-2003   PSF         yes
+ }
-+    2.3.4           2.3.3       2004        PSF         yes
+@@ -XXX,XX +XXX,XX @@ bool msi_is_masked(const PCIDevice *dev, unsigned int vector)
-+    2.3.5           2.3.4       2005        PSF         yes
+     return mask & (1U << vector);
-+    2.4             2.3         2004        PSF         yes
+ }
-+    2.4.1           2.4         2005        PSF         yes
-+    2.4.2           2.4.1       2005        PSF         yes
++void msi_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp)
-+    2.4.3           2.4.2       2006        PSF         yes
++{
-+    2.5             2.4         2006        PSF         yes
++    ERRP_GUARD();
-+    2.7             2.6         2010        PSF         yes
++    uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
-+
++    bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;
-+Footnotes:
++    uint32_t irq_state, vector_mask, pending;
 +
-+(1) GPL-compatible doesn't mean that we're distributing Python under
++    if (vector > PCI_MSI_VECTORS_MAX) {
-+    the GPL.  All Python licenses, unlike the GPL, let you distribute
++        error_setg(errp, "msi: vector %d not allocated. max vector is %d",
-+    a modified version without making your changes open source.  The
++                   vector, PCI_MSI_VECTORS_MAX);
-+    GPL-compatible licenses make it possible to combine Python with
++        return;
-+    other software that is released under the GPL; the others don't.
++    }
 +
-+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
++    vector_mask = (1U << vector);
-+    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
++    irq_state = pci_get_long(dev->config + msi_mask_off(dev, msi64bit));
-+    is "not incompatible" with the GPL.
++
-+
++    if (mask) {
-+Thanks to the many outside volunteers who have worked under Guido's
++        irq_state |= vector_mask;
-+direction to make these releases possible.
++    } else {
-+
++        irq_state &= ~vector_mask;
-+
++    }
-+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
++
-+===============================================================
++    pci_set_long(dev->config + msi_mask_off(dev, msi64bit), irq_state);
 +
-+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
++    pending = pci_get_long(dev->config + msi_pending_off(dev, msi64bit));
-+--------------------------------------------
++    if (!mask && (pending & vector_mask)) {
-+
++        pending &= ~vector_mask;
-+1. This LICENSE AGREEMENT is between the Python Software Foundation
++        pci_set_long(dev->config + msi_pending_off(dev, msi64bit), pending);
-+("PSF"), and the Individual or Organization ("Licensee") accessing and
++        msi_notify(dev, vector);
-+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
+ void msi_notify(PCIDevice *dev, unsigned int vector)
-+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+ {
-+license to reproduce, analyze, test, perform and/or display publicly,
+     uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
-+prepare derivative works, distribute, and otherwise use Python
+@@ -XXX,XX +XXX,XX @@ void msi_notify(PCIDevice *dev, unsigned int vector)
-+alone or in any derivative version, provided, however, that PSF's
-+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
+ void msi_send_message(PCIDevice *dev, MSIMessage msg)
-+2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights
+ {
-+Reserved" are retained in Python alone or in any derivative version
+-    MemTxAttrs attrs = {};
-+prepared by Licensee.
+-
-+
+-    attrs.requester_id = pci_requester_id(dev);
-+3. In the event Licensee prepares a derivative work that is based on
+-    address_space_stl_le(&dev->bus_master_as, msg.address, msg.data,
-+or incorporates Python or any part thereof, and wants to make
+-                         attrs, NULL);
-+the derivative work available to others as provided herein, then
++    dev->msi_trigger(dev, msg);
-+Licensee hereby agrees to include in any such work a brief summary of
+ }
-+the changes made to Python.
-+
+ /* Normally called by pci_default_write_config(). */
-+4. PSF is making Python available to Licensee on an "AS IS"
+diff --git a/hw/pci/msix.c b/hw/pci/msix.c
-+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+index XXXXXXX..XXXXXXX 100644
-+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+--- a/hw/pci/msix.c
-+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
++++ b/hw/pci/msix.c
-+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+@@ -XXX,XX +XXX,XX @@
-+INFRINGE ANY THIRD PARTY RIGHTS.
+ #define MSIX_ENABLE_MASK (PCI_MSIX_FLAGS_ENABLE >> 8)
-+
+ #define MSIX_MASKALL_MASK (PCI_MSIX_FLAGS_MASKALL >> 8)
-+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
-+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+-MSIMessage msix_get_message(PCIDevice *dev, unsigned vector)
-+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
++static MSIMessage msix_prepare_message(PCIDevice *dev, unsigned vector)
-+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+ {
-+
+     uint8_t *table_entry = dev->msix_table + vector * PCI_MSIX_ENTRY_SIZE;
-+6. This License Agreement will automatically terminate upon a material
+     MSIMessage msg;
-+breach of its terms and conditions.
+@@ -XXX,XX +XXX,XX @@ MSIMessage msix_get_message(PCIDevice *dev, unsigned vector)
-+
+     return msg;
-+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
++MSIMessage msix_get_message(PCIDevice *dev, unsigned vector)
-+trademarks or trade name in a trademark sense to endorse or promote
++{
-+products or services of Licensee, or any third party.
++    return dev->msix_prepare_message(dev, vector);
-+
++}
-+8. By copying, installing or otherwise using Python, Licensee
++
-+agrees to be bound by the terms and conditions of this License
+ /*
-+Agreement.
+  * Special API for POWER to configure the vectors through
-+
+  * a side channel. Should never be used by devices.
-+
+@@ -XXX,XX +XXX,XX @@ static void msix_handle_mask_update(PCIDevice *dev, int vector, bool was_masked)
-+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+     }
-+-------------------------------------------
+ }
-+
-+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
++void msix_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp)
-+
++{
-+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
++    ERRP_GUARD();
-+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
++    unsigned offset;
-+Individual or Organization ("Licensee") accessing and otherwise using
++    bool was_masked;
-+this software in source or binary form and its associated
++
-+documentation ("the Software").
++    if (vector > dev->msix_entries_nr) {
-+
++        error_setg(errp, "msix: vector %d not allocated. max vector is %d",
-+2. Subject to the terms and conditions of this BeOpen Python License
++                   vector, dev->msix_entries_nr);
-+Agreement, BeOpen hereby grants Licensee a non-exclusive,
++        return;
-+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,
++    offset = vector * PCI_MSIX_ENTRY_SIZE + PCI_MSIX_ENTRY_VECTOR_CTRL;
-+provided, however, that the BeOpen Python License is retained in the
++
-+Software, alone or in any derivative version prepared by Licensee.
++    was_masked = msix_is_masked(dev, vector);
 +
-+3. BeOpen is making the Software available to Licensee on an "AS IS"
++    if (mask) {
-+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
++        dev->msix_table[offset] |= PCI_MSIX_ENTRY_CTRL_MASKBIT;
-+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
++    } else {
-+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
++        dev->msix_table[offset] &= ~PCI_MSIX_ENTRY_CTRL_MASKBIT;
-+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
++    }
-+INFRINGE ANY THIRD PARTY RIGHTS.
++
-+
++    msix_handle_mask_update(dev, vector, was_masked);
-+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
+ static bool msix_masked(PCIDevice *dev)
-+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+ {
-+
+     return dev->config[dev->msix_cap + MSIX_CONTROL_OFFSET] & MSIX_MASKALL_MASK;
-+5. This License Agreement will automatically terminate upon a material
+@@ -XXX,XX +XXX,XX @@ int msix_init(struct PCIDevice *dev, unsigned short nentries,
-+breach of its terms and conditions.
+                           "msix-pba", pba_size);
-+
+     memory_region_add_subregion(pba_bar, pba_offset, &dev->msix_pba_mmio);
-+6. This License Agreement shall be governed by and interpreted in all
-+respects by the law of the State of California, excluding conflict of
++    dev->msix_prepare_message = msix_prepare_message;
-+law provisions.  Nothing in this License Agreement shall be deemed to
++
-+create any relationship of agency, partnership, or joint venture
+     return 0;
-+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
+@@ -XXX,XX +XXX,XX @@ void msix_uninit(PCIDevice *dev, MemoryRegion *table_bar, MemoryRegion *pba_bar)
-+third party.  As an exception, the "BeOpen Python" logos available at
+     g_free(dev->msix_entry_used);
-+http://www.pythonlabs.com/logos.html may be used according to the
+     dev->msix_entry_used = NULL;
-+permissions granted on that web page.
+     dev->cap_present &= ~QEMU_PCI_CAP_MSIX;
-+
++    dev->msix_prepare_message = NULL;
-+7. By copying, installing or otherwise using the software, Licensee
+ }
-+agrees to be bound by the terms and conditions of this License
-+Agreement.
+ void msix_uninit_exclusive_bar(PCIDevice *dev)
-+
+diff --git a/hw/pci/pci.c b/hw/pci/pci.c
-+
+index XXXXXXX..XXXXXXX 100644
-+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+--- a/hw/pci/pci.c
-+---------------------------------------
++++ b/hw/pci/pci.c
-+
+@@ -XXX,XX +XXX,XX @@ void pci_device_deassert_intx(PCIDevice *dev)
-+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
++static void pci_msi_trigger(PCIDevice *dev, MSIMessage msg)
-+source or binary form and its associated documentation.
++{
-+
++    MemTxAttrs attrs = {};
-+2. Subject to the terms and conditions of this License Agreement, CNRI
++
-+hereby grants Licensee a nonexclusive, royalty-free, world-wide
++    attrs.requester_id = pci_requester_id(dev);
-+license to reproduce, analyze, test, perform and/or display publicly,
++    address_space_stl_le(&dev->bus_master_as, msg.address, msg.data,
-+prepare derivative works, distribute, and otherwise use Python 1.6.1
++                         attrs, NULL);
-+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
+ static void pci_reset_regions(PCIDevice *dev)
-+Reserved" are retained in Python 1.6.1 alone or in any derivative
+ {
-+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+     int r;
-+Agreement, Licensee may substitute the following text (omitting the
+@@ -XXX,XX +XXX,XX @@ static void pci_qdev_unrealize(DeviceState *dev)
-+quotes): "Python 1.6.1 is made available subject to the terms and
-+conditions in CNRI's License Agreement.  This Agreement together with
+     pci_device_deassert_intx(pci_dev);
-+Python 1.6.1 may be located on the Internet using the following
+     do_pci_unregister_device(pci_dev);
-+unique, persistent identifier (known as a handle): 1895.22/1013.  This
++
-+Agreement may also be obtained from a proxy server on the Internet
++    pci_dev->msi_trigger = NULL;
-+using the following URL: http://hdl.handle.net/1895.22/1013".
+ }
-+
-+3. In the event Licensee prepares a derivative work that is based on
+ void pci_register_bar(PCIDevice *pci_dev, int region_num,
-+or incorporates Python 1.6.1 or any part thereof, and wants to make
+@@ -XXX,XX +XXX,XX @@ static void pci_qdev_realize(DeviceState *qdev, Error **errp)
-+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.
+     pci_set_power(pci_dev, true);
 +
-+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
++    pci_dev->msi_trigger = pci_msi_trigger;
-+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
+ PCIDevice *pci_new_multifunction(int devfn, bool multifunction,
-+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+diff --git a/hw/remote/machine.c b/hw/remote/machine.c
-+INFRINGE ANY THIRD PARTY RIGHTS.
+index XXXXXXX..XXXXXXX 100644
-+
+--- a/hw/remote/machine.c
-+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
++++ b/hw/remote/machine.c
-+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+@@ -XXX,XX +XXX,XX @@
-+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+ #include "hw/remote/iommu.h"
-+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+ #include "hw/qdev-core.h"
-+
+ #include "hw/remote/iommu.h"
-+6. This License Agreement will automatically terminate upon a material
++#include "hw/remote/vfio-user-obj.h"
-+breach of its terms and conditions.
++#include "hw/pci/msi.h"
-+
-+7. This License Agreement shall be governed by the federal
+ static void remote_machine_init(MachineState *machine)
-+intellectual property law of the United States, including without
+ {
-+limitation the federal copyright law, and, to the extent such
+@@ -XXX,XX +XXX,XX @@ static void remote_machine_init(MachineState *machine)
-+U.S. federal law does not apply, by the law of the Commonwealth of
-+Virginia, excluding Virginia's conflict of law provisions.
+     if (s->vfio_user) {
-+Notwithstanding the foregoing, with regard to derivative works based
+         remote_iommu_setup(pci_host->bus);
-+on Python 1.6.1 that incorporate non-separable material that was
++
-+previously distributed under the GNU General Public License (GPL), the
++        msi_nonbroken = true;
-+law of the Commonwealth of Virginia shall govern this License
++
-+Agreement only as to issues arising under or with respect to
++        vfu_object_set_bus_irq(pci_host->bus);
-+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
++    } else {
-+License Agreement shall be deemed to create any relationship of
++        remote_iohub_init(&s->iohub);
-+agency, partnership, or joint venture between CNRI and Licensee.  This
++
-+License Agreement does not grant permission to use CNRI trademarks or
++        pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, remote_iohub_map_irq,
-+trade name in a trademark sense to endorse or promote products or
++                     &s->iohub, REMOTE_IOHUB_NB_PIRQS);
-+services of Licensee, or any third party.
+     }
-+
-+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+-    remote_iohub_init(&s->iohub);
-+installing or otherwise using Python 1.6.1, Licensee agrees to be
+-
-+bound by the terms and conditions of this License Agreement.
+-    pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, remote_iohub_map_irq,
-+
+-                 &s->iohub, REMOTE_IOHUB_NB_PIRQS);
-+        ACCEPT
+-
-+
+     qbus_set_hotplug_handler(BUS(pci_host->bus), OBJECT(s));
-+
+ }
-+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
-+--------------------------------------------------
+diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
-+
+index XXXXXXX..XXXXXXX 100644
-+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+--- a/hw/remote/vfio-user-obj.c
-+The Netherlands.  All rights reserved.
++++ b/hw/remote/vfio-user-obj.c
-+
+@@ -XXX,XX +XXX,XX @@
-+Permission to use, copy, modify, and distribute this software and its
+ #include "hw/pci/pci.h"
-+documentation for any purpose and without fee is hereby granted,
+ #include "qemu/timer.h"
-+provided that the above copyright notice appear in all copies and that
+ #include "exec/memory.h"
-+both that copyright notice and this permission notice appear in
++#include "hw/pci/msi.h"
-+supporting documentation, and that the name of Stichting Mathematisch
++#include "hw/pci/msix.h"
-+Centrum or CWI not be used in advertising or publicity pertaining to
++#include "hw/remote/vfio-user-obj.h"
-+distribution of the software without specific, written prior
-+permission.
+ #define TYPE_VFU_OBJECT "x-vfio-user-server"
-+
+ OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
-+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+@@ -XXX,XX +XXX,XX @@ struct VfuObject {
-+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+     Error *unplug_blocker;
-+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
-+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+     int vfu_poll_fd;
-+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
++
-+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
++    MSITriggerFunc *default_msi_trigger;
-+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++    MSIPrepareMessageFunc *default_msi_prepare_message;
-diff --git a/scripts/argparse.py b/scripts/argparse.py
++    MSIxPrepareMessageFunc *default_msix_prepare_message;
  };
  static void vfu_object_init_ctx(VfuObject *o, Error **errp);
@@ -XXX,XX +XXX,XX @@ static void vfu_object_register_bars(vfu_ctx_t *vfu_ctx, PCIDevice *pdev)
      }
  }
 +static int vfu_object_map_irq(PCIDevice *pci_dev, int intx)
 +{
 +    int pci_bdf = PCI_BUILD_BDF(pci_bus_num(pci_get_bus(pci_dev)),
 +                                pci_dev->devfn);
 +
 +    return pci_bdf;
 +}
 +
 +static void vfu_object_set_irq(void *opaque, int pirq, int level)
 +{
 +    PCIBus *pci_bus = opaque;
 +    PCIDevice *pci_dev = NULL;
 +    vfu_ctx_t *vfu_ctx = NULL;
 +    int pci_bus_num, devfn;
 +
 +    if (level) {
 +        pci_bus_num = PCI_BUS_NUM(pirq);
 +        devfn = PCI_BDF_TO_DEVFN(pirq);
 +
 +        /*
 +         * pci_find_device() performs at O(1) if the device is attached
 +         * to the root PCI bus. Whereas, if the device is attached to a
 +         * secondary PCI bus (such as when a root port is involved),
 +         * finding the parent PCI bus could take O(n)
 +         */
 +        pci_dev = pci_find_device(pci_bus, pci_bus_num, devfn);
 +
 +        vfu_ctx = pci_dev->irq_opaque;
 +
 +        g_assert(vfu_ctx);
 +
 +        vfu_irq_trigger(vfu_ctx, 0);
 +    }
 +}
 +
 +static MSIMessage vfu_object_msi_prepare_msg(PCIDevice *pci_dev,
 +                                             unsigned int vector)
 +{
 +    MSIMessage msg;
 +
 +    msg.address = 0;
 +    msg.data = vector;
 +
 +    return msg;
 +}
 +
 +static void vfu_object_msi_trigger(PCIDevice *pci_dev, MSIMessage msg)
 +{
 +    vfu_ctx_t *vfu_ctx = pci_dev->irq_opaque;
 +
 +    vfu_irq_trigger(vfu_ctx, msg.data);
 +}
 +
 +static void vfu_object_setup_msi_cbs(VfuObject *o)
 +{
 +    o->default_msi_trigger = o->pci_dev->msi_trigger;
 +    o->default_msi_prepare_message = o->pci_dev->msi_prepare_message;
 +    o->default_msix_prepare_message = o->pci_dev->msix_prepare_message;
 +
 +    o->pci_dev->msi_trigger = vfu_object_msi_trigger;
 +    o->pci_dev->msi_prepare_message = vfu_object_msi_prepare_msg;
 +    o->pci_dev->msix_prepare_message = vfu_object_msi_prepare_msg;
 +}
 +
 +static void vfu_object_restore_msi_cbs(VfuObject *o)
 +{
 +    o->pci_dev->msi_trigger = o->default_msi_trigger;
 +    o->pci_dev->msi_prepare_message = o->default_msi_prepare_message;
 +    o->pci_dev->msix_prepare_message = o->default_msix_prepare_message;
 +}
 +
 +static void vfu_msix_irq_state(vfu_ctx_t *vfu_ctx, uint32_t start,
 +                               uint32_t count, bool mask)
 +{
 +    VfuObject *o = vfu_get_private(vfu_ctx);
 +    Error *err = NULL;
 +    uint32_t vector;
 +
 +    for (vector = start; vector < count; vector++) {
 +        msix_set_mask(o->pci_dev, vector, mask, &err);
 +        if (err) {
 +            VFU_OBJECT_ERROR(o, "vfu: %s: %s", o->device,
 +                             error_get_pretty(err));
 +            error_free(err);
 +            err = NULL;
 +        }
 +    }
 +}
 +
 +static void vfu_msi_irq_state(vfu_ctx_t *vfu_ctx, uint32_t start,
 +                              uint32_t count, bool mask)
 +{
 +    VfuObject *o = vfu_get_private(vfu_ctx);
 +    Error *err = NULL;
 +    uint32_t vector;
 +
 +    for (vector = start; vector < count; vector++) {
 +        msi_set_mask(o->pci_dev, vector, mask, &err);
 +        if (err) {
 +            VFU_OBJECT_ERROR(o, "vfu: %s: %s", o->device,
 +                             error_get_pretty(err));
 +            error_free(err);
 +            err = NULL;
 +        }
 +    }
 +}
 +
 +static int vfu_object_setup_irqs(VfuObject *o, PCIDevice *pci_dev)
 +{
 +    vfu_ctx_t *vfu_ctx = o->vfu_ctx;
 +    int ret;
 +
 +    ret = vfu_setup_device_nr_irqs(vfu_ctx, VFU_DEV_INTX_IRQ, 1);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
 +    if (msix_nr_vectors_allocated(pci_dev)) {
 +        ret = vfu_setup_device_nr_irqs(vfu_ctx, VFU_DEV_MSIX_IRQ,
 +                                       msix_nr_vectors_allocated(pci_dev));
 +        vfu_setup_irq_state_callback(vfu_ctx, VFU_DEV_MSIX_IRQ,
 +                                     &vfu_msix_irq_state);
 +    } else if (msi_nr_vectors_allocated(pci_dev)) {
 +        ret = vfu_setup_device_nr_irqs(vfu_ctx, VFU_DEV_MSI_IRQ,
 +                                       msi_nr_vectors_allocated(pci_dev));
 +        vfu_setup_irq_state_callback(vfu_ctx, VFU_DEV_MSI_IRQ,
 +                                     &vfu_msi_irq_state);
 +    }
 +
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
 +    vfu_object_setup_msi_cbs(o);
 +
 +    pci_dev->irq_opaque = vfu_ctx;
 +
 +    return 0;
 +}
 +
 +void vfu_object_set_bus_irq(PCIBus *pci_bus)
 +{
 +    int bus_num = pci_bus_num(pci_bus);
 +    int max_bdf = PCI_BUILD_BDF(bus_num, PCI_DEVFN_MAX - 1);
 +
 +    pci_bus_irqs(pci_bus, vfu_object_set_irq, vfu_object_map_irq, pci_bus,
 +                 max_bdf);
 +}
 +
  /*
   * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
   * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
      vfu_object_register_bars(o->vfu_ctx, o->pci_dev);
 +    ret = vfu_object_setup_irqs(o, o->pci_dev);
 +    if (ret < 0) {
 +        error_setg(errp, "vfu: Failed to setup interrupts for %s",
 +                   o->device);
 +        goto fail;
 +    }
 +
      ret = vfu_realize_ctx(o->vfu_ctx);
      if (ret < 0) {
          error_setg(errp, "vfu: Failed to realize device %s- %s",
@@ -XXX,XX +XXX,XX @@ fail:
          o->unplug_blocker = NULL;
      }
      if (o->pci_dev) {
 +        vfu_object_restore_msi_cbs(o);
 +        o->pci_dev->irq_opaque = NULL;
          object_unref(OBJECT(o->pci_dev));
          o->pci_dev = NULL;
      }
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
      }
      if (o->pci_dev) {
 +        vfu_object_restore_msi_cbs(o);
 +        o->pci_dev->irq_opaque = NULL;
          object_unref(OBJECT(o->pci_dev));
          o->pci_dev = NULL;
      }
 diff --git a/stubs/vfio-user-obj.c b/stubs/vfio-user-obj.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/scripts/argparse.py
++++ b/stubs/vfio-user-obj.c
 @@ -XXX,XX +XXX,XX @@
-+# This is a local copy of the standard library argparse module taken from PyPI.
++#include "qemu/osdep.h"
-+# It is licensed under the Python Software Foundation License.  This is a
++#include "hw/remote/vfio-user-obj.h"
-+# 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
++void vfu_object_set_bus_irq(PCIBus *pci_bus)
-+# anything in sys.path.
++{
-+#
++}
-+# If your script is not located in the same directory as this file, import it
+diff --git a/hw/remote/trace-events b/hw/remote/trace-events
-+# like this:
+index XXXXXXX..XXXXXXX 100644
-+#
+--- a/hw/remote/trace-events
-+#   import os
++++ b/hw/remote/trace-events
-+#   import sys
+@@ -XXX,XX +XXX,XX @@ vfu_dma_unregister(uint64_t gpa) "vfu: unregistering GPA 0x%"PRIx64""
-+#   sys.path.append(os.path.join(os.path.dirname(__file__), ..., 'scripts'))
+ vfu_bar_register(int i, uint64_t addr, uint64_t size) "vfu: BAR %d: addr 0x%"PRIx64" size 0x%"PRIx64""
-+#   import argparse
+ vfu_bar_rw_enter(const char *op, uint64_t addr) "vfu: %s request for BAR address 0x%"PRIx64""
-+
+ vfu_bar_rw_exit(const char *op, uint64_t addr) "vfu: Finished %s of BAR address 0x%"PRIx64""
-+# Author: Steven J. Bethard <steven.bethard@gmail.com>.
++vfu_interrupt(int pirq) "vfu: sending interrupt to device - PIRQ %d"
-+# Maintainer: Thomas Waldmann <tw@waldmann-edv.de>
+diff --git a/stubs/meson.build b/stubs/meson.build
-+
+index XXXXXXX..XXXXXXX 100644
-+"""Command-line parsing library
+--- a/stubs/meson.build
-+
++++ b/stubs/meson.build
-+This module is an optparse-inspired command-line parsing library that:
+@@ -XXX,XX +XXX,XX @@ if have_system
-+
+ else
-+    - handles both optional and positional arguments
+   stub_ss.add(files('qdev.c'))
-+    - produces highly informative usage messages
+ endif
-+    - supports parsers that dispatch to sub-parsers
++stub_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_false: files('vfio-user-obj.c'))
 +
 +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))
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 15/15] qcow2: allocate cluster_cache/cluster_data on demand
+[PULL 16/18] vfio-user: handle reset of remote device
-Most qcow2 files are uncompressed so it is wasteful to allocate (32 + 1)
+From: Jagannathan Raman <jag.raman@oracle.com>
 * 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
+Adds handler to reset a remote device
 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
+Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
-disks are attached or backing file chains are long:
+Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
+Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
-Before 12.81% (1,023,193,088B)
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-After   5.36% (393,893,888B)
+Message-id: 112eeadf3bc4c6cdb100bc3f9a6fcfc20b467c1b.1655151679.git.jag.raman@oracle.com
 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 +++++++++++++++++
+ hw/remote/vfio-user-obj.c | 20 ++++++++++++++++++++
- block/qcow2.c         | 12 ------------
+file changed, 20 insertions(+)
 files changed, 17 insertions(+), 12 deletions(-)
-diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2-cluster.c
+--- a/hw/remote/vfio-user-obj.c
-+++ b/block/qcow2-cluster.c
++++ b/hw/remote/vfio-user-obj.c
-@@ -XXX,XX +XXX,XX @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
+@@ -XXX,XX +XXX,XX @@ void vfu_object_set_bus_irq(PCIBus *pci_bus)
-         nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
+                  max_bdf);
-         sector_offset = coffset & 511;
+ }
-         csize = nb_csectors * 512 - sector_offset;
 +static int vfu_object_device_reset(vfu_ctx_t *vfu_ctx, vfu_reset_type_t type)
 +{
 +    VfuObject *o = vfu_get_private(vfu_ctx);
 +
-+        /* Allocate buffers on first decompress operation, most images are
++    /* vfu_object_ctx_run() handles lost connection */
-+         * uncompressed and the memory overhead can be avoided.  The buffers
++    if (type == VFU_RESET_LOST_CONN) {
-+         * are freed in .bdrv_close().
++        return 0;
-+         */
++    }
 +        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);
++    qdev_reset_all(DEVICE(o->pci_dev));
-         ret = bdrv_read(bs->file, coffset >> 9, s->cluster_data,
++
-                         nb_csectors);
++    return 0;
-diff --git a/block/qcow2.c b/block/qcow2.c
++}
-index XXXXXXX..XXXXXXX 100644
++
---- a/block/qcow2.c
+ /*
-+++ b/block/qcow2.c
+  * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
-@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+  * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
          goto fail;
      }
--    s->cluster_cache = g_malloc(s->cluster_size);
++    ret = vfu_setup_device_reset_cb(o->vfu_ctx, &vfu_object_device_reset);
--    /* one more sector for decompressed data alignment */
++    if (ret < 0) {
--    s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
++        error_setg(errp, "vfu: Failed to setup reset callback");
--                                                    * s->cluster_size + 512);
++        goto fail;
--    if (s->cluster_data == NULL) {
++    }
--        error_setg(errp, "Could not allocate temporary cluster buffer");
++
--        ret = -ENOMEM;
+     ret = vfu_realize_ctx(o->vfu_ctx);
--        goto fail;
+     if (ret < 0) {
--    }
+         error_setg(errp, "vfu: Failed to realize device %s- %s",
 -
      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;
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 12/15] docker.py: Python 2.6 argparse compatibility
+[PULL 17/18] linux-aio: fix unbalanced plugged counter in laio_io_unplug()
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+Every laio_io_plug() call has a matching laio_io_unplug() call. There is
-import argparse.
+a plugged counter that tracks the number of levels of plugging and
 allows for nesting.
-Cc: Fam Zheng <famz@redhat.com>
+The plugged counter must reflect the balance between laio_io_plug() and
 laio_io_unplug() calls accurately. Otherwise I/O stalls occur since
 io_submit(2) calls are skipped while plugged.
 Reported-by: Nikolay Tenev <nt@storpool.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Acked-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
-Acked-by: Fam Zheng <famz@redhat.com>
+Message-id: 20220609164712.1539045-2-stefanha@redhat.com
-Message-id: 20170825155732.15665-3-stefanha@redhat.com
+Cc: Stefano Garzarella <sgarzare@redhat.com>
 Fixes: 68d7946648 ("linux-aio: add `dev_max_batch` parameter to laio_io_unplug()")
 [Stefano Garzarella suggested adding a Fixes tag.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/docker/docker.py | 4 +++-
+ block/linux-aio.c | 4 +++-
 file changed, 3 insertions(+), 1 deletion(-)
-diff --git a/tests/docker/docker.py b/tests/docker/docker.py
+diff --git a/block/linux-aio.c b/block/linux-aio.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/docker/docker.py
+--- a/block/linux-aio.c
-+++ b/tests/docker/docker.py
++++ b/block/linux-aio.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void laio_io_unplug(BlockDriverState *bs, LinuxAioState *s,
+                     uint64_t dev_max_batch)
- import os
+ {
- import sys
+     assert(s->io_q.plugged);
-+sys.path.append(os.path.join(os.path.dirname(__file__),
++    s->io_q.plugged--;
-+                             '..', '..', 'scripts'))
++
-+import argparse
+     if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch) ||
- import subprocess
+-        (--s->io_q.plugged == 0 &&
- import json
++        (!s->io_q.plugged &&
- import hashlib
+          !s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending))) {
- import atexit
+         ioq_submit(s);
- import uuid
+     }
 -import argparse
  import tempfile
  import re
  import signal
 --
-.13.5
+.36.1

-[Qemu-devel] [PULL for-2.10 01/15] nvme: Fix get/set number of queues feature, again
+[PULL 18/18] linux-aio: explain why max batch is checked in laio_io_unplug()
-From: Dan Aloni <dan@kernelim.com>
+It may not be obvious why laio_io_unplug() checks max batch. I discussed
 this with Stefano and have added a comment summarizing the reason.
-The number of queues that should be return by the admin command should:
+Cc: Stefano Garzarella <sgarzare@redhat.com>
+Cc: Kevin Wolf <kwolf@redhat.com>
-) Only mention the number of non-admin queues.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-) It is zero-based, meaning that '0 == one non-admin queue',
+Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
-     '1 == two non-admin queues', and so forth.
+Message-id: 20220609164712.1539045-3-stefanha@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 ++--
+ block/linux-aio.c | 6 ++++++
-file changed, 2 insertions(+), 2 deletions(-)
+file changed, 6 insertions(+)
-diff --git a/hw/block/nvme.c b/hw/block/nvme.c
+diff --git a/block/linux-aio.c b/block/linux-aio.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/nvme.c
+--- a/block/linux-aio.c
-+++ b/hw/block/nvme.c
++++ b/block/linux-aio.c
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
+@@ -XXX,XX +XXX,XX @@ void laio_io_unplug(BlockDriverState *bs, LinuxAioState *s,
-         result = blk_enable_write_cache(n->conf.blk);
+     assert(s->io_q.plugged);
-         break;
+     s->io_q.plugged--;
-     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));
++     * Why max batch checking is performed here:
-         break;
++     * Another BDS may have queued requests with a higher dev_max_batch and
-     default:
++     * therefore in_queue could now exceed our dev_max_batch. Re-check the max
-         return NVME_INVALID_FIELD | NVME_DNR;
++     * batch so we can honor our device's dev_max_batch.
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
++     */
-         break;
+     if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch) ||
-     case NVME_NUMBER_OF_QUEUES:
+         (!s->io_q.plugged &&
-         req->cqe.result =
+          !s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending))) {
 -            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;
 --
-.13.5
+.36.1

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 8e6c70b9d4a1b1f3011805947925cfdb31642f7f:

Merge tag 'kraxel-20220614-pull-request' of git://git.kraxel.org/qemu into staging (2022-06-14 06:21:46 -0700)

are available in the Git repository at:

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

for you to fetch changes up to 99b969fbe105117f5af6060d3afef40ca39cc9c1:

linux-aio: explain why max batch is checked in laio_io_unplug() (2022-06-15 16:43:42 +0100)

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

This pull request includes an important aio=native I/O stall fix, the
experimental vifo-user server, the io_uring_register_ring_fd() optimization for
aio=io_uring, and an update to Vladimir Sementsov-Ogievskiy's maintainership
details.

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

Jagannathan Raman (14):
  qdev: unplug blocker for devices
  remote/machine: add HotplugHandler for remote machine
  remote/machine: add vfio-user property
  vfio-user: build library
  vfio-user: define vfio-user-server object
  vfio-user: instantiate vfio-user context
  vfio-user: find and init PCI device
  vfio-user: run vfio-user context
  vfio-user: handle PCI config space accesses
  vfio-user: IOMMU support for remote device
  vfio-user: handle DMA mappings
  vfio-user: handle PCI BAR accesses
  vfio-user: handle device interrupts
  vfio-user: handle reset of remote device

Sam Li (1):
  Use io_uring_register_ring_fd() to skip fd operations

Stefan Hajnoczi (2):
  linux-aio: fix unbalanced plugged counter in laio_io_unplug()
  linux-aio: explain why max batch is checked in laio_io_unplug()

Vladimir Sementsov-Ogievskiy (1):
  MAINTAINERS: update Vladimir's address and repositories

-- 
2.36.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Message-id: 20220526115432.138384-1-vsementsov@yandex-team.ru
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: scsi/*
 
 Block Jobs
 M: John Snow <jsnow@redhat.com>
-M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
+M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
 L: qemu-block@nongnu.org
 S: Supported
 F: blockjob.c
@@ -XXX,XX +XXX,XX @@ F: block/aio_task.c
 F: util/qemu-co-shared-resource.c
 F: include/qemu/co-shared-resource.h
 T: git https://gitlab.com/jsnow/qemu.git jobs
-T: git https://src.openvz.org/scm/~vsementsov/qemu.git jobs
+T: git https://gitlab.com/vsementsov/qemu.git block
 
 Block QAPI, monitor, command line
 M: Markus Armbruster <armbru@redhat.com>
@@ -XXX,XX +XXX,XX @@ F: include/hw/cxl/
 
 Dirty Bitmaps
 M: Eric Blake <eblake@redhat.com>
-M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
+M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
 R: John Snow <jsnow@redhat.com>
 L: qemu-block@nongnu.org
 S: Supported
@@ -XXX,XX +XXX,XX @@ F: util/hbitmap.c
 F: tests/unit/test-hbitmap.c
 F: docs/interop/bitmaps.rst
 T: git https://repo.or.cz/qemu/ericb.git bitmaps
+T: git https://gitlab.com/vsementsov/qemu.git block
 
 Character device backends
 M: Marc-André Lureau <marcandre.lureau@redhat.com>
@@ -XXX,XX +XXX,XX @@ F: scripts/*.py
 F: tests/*.py
 
 Benchmark util
-M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
+M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
 S: Maintained
 F: scripts/simplebench/
-T: git https://src.openvz.org/scm/~vsementsov/qemu.git simplebench
+T: git https://gitlab.com/vsementsov/qemu.git simplebench
 
 Transactions helper
-M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
+M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
 S: Maintained
 F: include/qemu/transactions.h
 F: util/transactions.c
+T: git https://gitlab.com/vsementsov/qemu.git block
 
 QAPI
 M: Markus Armbruster <armbru@redhat.com>
@@ -XXX,XX +XXX,XX @@ F: block/iscsi-opts.c
 
 Network Block Device (NBD)
 M: Eric Blake <eblake@redhat.com>
-M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
+M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
 L: qemu-block@nongnu.org
 S: Maintained
 F: block/nbd*
@@ -XXX,XX +XXX,XX @@ F: docs/interop/nbd.txt
 F: docs/tools/qemu-nbd.rst
 F: tests/qemu-iotests/tests/*nbd*
 T: git https://repo.or.cz/qemu/ericb.git nbd
-T: git https://src.openvz.org/scm/~vsementsov/qemu.git nbd
+T: git https://gitlab.com/vsementsov/qemu.git block
 
 NFS
 M: Peter Lieven <pl@kamp.de>
@@ -XXX,XX +XXX,XX @@ F: block/dmg.c
 parallels
 M: Stefan Hajnoczi <stefanha@redhat.com>
 M: Denis V. Lunev <den@openvz.org>
-M: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
+M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
 L: qemu-block@nongnu.org
 S: Supported
 F: block/parallels.c
 F: block/parallels-ext.c
 F: docs/interop/parallels.txt
-T: git https://src.openvz.org/scm/~vsementsov/qemu.git parallels
+T: git https://gitlab.com/vsementsov/qemu.git block
 
 qed
 M: Stefan Hajnoczi <stefanha@redhat.com>
-- 
2.36.1

From: Sam Li <faithilikerun@gmail.com>

Linux recently added a new io_uring(7) optimization API that QEMU
doesn't take advantage of yet. The liburing library that QEMU uses
has added a corresponding new API calling io_uring_register_ring_fd().
When this API is called after creating the ring, the io_uring_submit()
library function passes a flag to the io_uring_enter(2) syscall
allowing it to skip the ring file descriptor fdget()/fdput()
operations. This saves some CPU cycles.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Message-id: 20220531105011.111082-1-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 meson.build      |  1 +
 block/io_uring.c | 12 +++++++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_LIBNFS', libnfs.found())
 config_host_data.set('CONFIG_LIBSSH', libssh.found())
 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
+config_host_data.set('CONFIG_LIBURING_REGISTER_RING_FD', cc.has_function('io_uring_register_ring_fd', prefix: '#include <liburing.h>', dependencies:linux_io_uring))
 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
 config_host_data.set('CONFIG_NUMA', numa.found())
 config_host_data.set('CONFIG_OPENGL', opengl.found())
diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/error.h"
 #include "trace.h"
 
+
 /* io_uring ring size */
 #define MAX_ENTRIES 128
 
@@ -XXX,XX +XXX,XX @@ LuringState *luring_init(Error **errp)
     }
 
     ioq_init(&s->io_q);
+#ifdef CONFIG_LIBURING_REGISTER_RING_FD
+    if (io_uring_register_ring_fd(&s->ring) < 0) {
+        /*
+         * Only warn about this error: we will fallback to the non-optimized
+         * io_uring operations.
+         */
+        warn_report("failed to register linux io_uring ring file descriptor");
+    }
+#endif
+
     return s;
-
 }
 
 void luring_cleanup(LuringState *s)
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Add blocker to prevent hot-unplug of devices

TYPE_VFIO_USER_SERVER, which is introduced shortly, attaches itself to a
PCIDevice on which it depends. If the attached PCIDevice gets removed
while the server in use, it could cause it crash. To prevent this,
TYPE_VFIO_USER_SERVER adds an unplug blocker for the PCIDevice.

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: c41ef80b7cc063314d629737bed2159e5713f2e0.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/qdev-core.h | 29 +++++++++++++++++++++++++++++
 hw/core/qdev.c         | 24 ++++++++++++++++++++++++
 softmmu/qdev-monitor.c |  4 ++++
 3 files changed, 57 insertions(+)

diff --git a/include/hw/qdev-core.h b/include/hw/qdev-core.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/qdev-core.h
+++ b/include/hw/qdev-core.h
@@ -XXX,XX +XXX,XX @@ struct DeviceState {
     int instance_id_alias;
     int alias_required_for_version;
     ResettableState reset;
+    GSList *unplug_blockers;
 };
 
 struct DeviceListener {
@@ -XXX,XX +XXX,XX @@ void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
 void qdev_machine_creation_done(void);
 bool qdev_machine_modified(void);
 
+/**
+ * qdev_add_unplug_blocker: Add an unplug blocker to a device
+ *
+ * @dev: Device to be blocked from unplug
+ * @reason: Reason for blocking
+ */
+void qdev_add_unplug_blocker(DeviceState *dev, Error *reason);
+
+/**
+ * qdev_del_unplug_blocker: Remove an unplug blocker from a device
+ *
+ * @dev: Device to be unblocked
+ * @reason: Pointer to the Error used with qdev_add_unplug_blocker.
+ *          Used as a handle to lookup the blocker for deletion.
+ */
+void qdev_del_unplug_blocker(DeviceState *dev, Error *reason);
+
+/**
+ * qdev_unplug_blocked: Confirm if a device is blocked from unplug
+ *
+ * @dev: Device to be tested
+ * @reason: Returns one of the reasons why the device is blocked,
+ *          if any
+ *
+ * Returns: true if device is blocked from unplug, false otherwise
+ */
+bool qdev_unplug_blocked(DeviceState *dev, Error **errp);
+
 /**
  * GpioPolarity: Polarity of a GPIO line
  *
diff --git a/hw/core/qdev.c b/hw/core/qdev.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/core/qdev.c
+++ b/hw/core/qdev.c
@@ -XXX,XX +XXX,XX @@ char *qdev_get_dev_path(DeviceState *dev)
     return NULL;
 }
 
+void qdev_add_unplug_blocker(DeviceState *dev, Error *reason)
+{
+    dev->unplug_blockers = g_slist_prepend(dev->unplug_blockers, reason);
+}
+
+void qdev_del_unplug_blocker(DeviceState *dev, Error *reason)
+{
+    dev->unplug_blockers = g_slist_remove(dev->unplug_blockers, reason);
+}
+
+bool qdev_unplug_blocked(DeviceState *dev, Error **errp)
+{
+    ERRP_GUARD();
+
+    if (dev->unplug_blockers) {
+        error_propagate(errp, error_copy(dev->unplug_blockers->data));
+        return true;
+    }
+
+    return false;
+}
+
 static bool device_get_realized(Object *obj, Error **errp)
 {
     DeviceState *dev = DEVICE(obj);
@@ -XXX,XX +XXX,XX @@ static void device_finalize(Object *obj)
 
     DeviceState *dev = DEVICE(obj);
 
+    g_assert(!dev->unplug_blockers);
+
     QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
         QLIST_REMOVE(ngl, node);
         qemu_free_irqs(ngl->in, ngl->num_in);
diff --git a/softmmu/qdev-monitor.c b/softmmu/qdev-monitor.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/qdev-monitor.c
+++ b/softmmu/qdev-monitor.c
@@ -XXX,XX +XXX,XX @@ void qdev_unplug(DeviceState *dev, Error **errp)
     HotplugHandlerClass *hdc;
     Error *local_err = NULL;
 
+    if (qdev_unplug_blocked(dev, errp)) {
+        return;
+    }
+
     if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
         error_setg(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
         return;
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Allow hotplugging of PCI(e) devices to remote machine

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: d1e6cfa0afb528ad343758f9b1d918be0175c5e5.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/remote/machine.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

From: Jagannathan Raman <jag.raman@oracle.com>

Add vfio-user to x-remote machine. It is a boolean, which indicates if
the machine supports vfio-user protocol. The machine configures the bus
differently vfio-user and multiprocess protocols, so this property
informs it on how to configure the bus.

This property should be short lived. Once vfio-user fully replaces
multiprocess, this property could be removed.

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 5d51a152a419cbda35d070b8e49b772b60a7230a.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/remote/machine.h |  2 ++
 hw/remote/machine.c         | 23 +++++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/include/hw/remote/machine.h b/include/hw/remote/machine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/remote/machine.h
+++ b/include/hw/remote/machine.h
@@ -XXX,XX +XXX,XX @@ struct RemoteMachineState {
 
     RemotePCIHost *host;
     RemoteIOHubState iohub;
+
+    bool vfio_user;
 };
 
 /* Used to pass to co-routine device and ioc. */
diff --git a/hw/remote/machine.c b/hw/remote/machine.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/machine.c
+++ b/hw/remote/machine.c
@@ -XXX,XX +XXX,XX @@ static void remote_machine_init(MachineState *machine)
     qbus_set_hotplug_handler(BUS(pci_host->bus), OBJECT(s));
 }
 
+static bool remote_machine_get_vfio_user(Object *obj, Error **errp)
+{
+    RemoteMachineState *s = REMOTE_MACHINE(obj);
+
+    return s->vfio_user;
+}
+
+static void remote_machine_set_vfio_user(Object *obj, bool value, Error **errp)
+{
+    RemoteMachineState *s = REMOTE_MACHINE(obj);
+
+    if (phase_check(PHASE_MACHINE_CREATED)) {
+        error_setg(errp, "Error enabling vfio-user - machine already created");
+        return;
+    }
+
+    s->vfio_user = value;
+}
+
 static void remote_machine_class_init(ObjectClass *oc, void *data)
 {
     MachineClass *mc = MACHINE_CLASS(oc);
@@ -XXX,XX +XXX,XX @@ static void remote_machine_class_init(ObjectClass *oc, void *data)
     mc->desc = "Experimental remote machine";
 
     hc->unplug = qdev_simple_device_unplug_cb;
+
+    object_class_property_add_bool(oc, "vfio-user",
+                                   remote_machine_get_vfio_user,
+                                   remote_machine_set_vfio_user);
 }
 
 static const TypeInfo remote_machine = {
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

add the libvfio-user library as a submodule. build it as a meson
subproject.

libvfio-user is distributed with BSD 3-Clause license and
json-c with MIT (Expat) license

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: c2adec87958b081d1dc8775d4aa05c897912f025.1655151679.git.jag.raman@oracle.com

[Changed submodule URL to QEMU's libvfio-user mirror on GitLab. The QEMU
project mirrors its dependencies so that it can provide full source code
even in the event that its dependencies become unavailable. Note that
the mirror repo is manually updated, so please contact me to make newer
libvfio-user commits available. If I become a bottleneck we can set up a
cronjob.

Updated scripts/meson-buildoptions.sh to match the meson_options.txt
change. Failure to do so can result in scripts/meson-buildoptions.sh
being modified by the build system later on and you end up with a dirty
working tree.
--Stefan]

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: hw/remote/proxy-memory-listener.c
 F: include/hw/remote/proxy-memory-listener.h
 F: hw/remote/iohub.c
 F: include/hw/remote/iohub.h
+F: subprojects/libvfio-user
 
 EBPF:
 M: Jason Wang <jasowang@redhat.com>
diff --git a/meson_options.txt b/meson_options.txt
index XXXXXXX..XXXXXXX 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -XXX,XX +XXX,XX @@ option('cfi_debug', type: 'boolean', value: 'false',
        description: 'Verbose errors in case of CFI violation')
 option('multiprocess', type: 'feature', value: 'auto',
        description: 'Out of process device emulation support')
+option('vfio_user_server', type: 'feature', value: 'disabled',
+       description: 'vfio-user server support')
 option('dbus_display', type: 'feature', value: 'auto',
        description: '-display dbus support')
 option('tpm', type : 'feature', value : 'auto',
diff --git a/configure b/configure
index XXXXXXX..XXXXXXX 100755
--- a/configure
+++ b/configure
@@ -XXX,XX +XXX,XX @@ meson_args=""
 ninja=""
 bindir="bin"
 skip_meson=no
+vfio_user_server="disabled"
 
 # The following Meson options are handled manually (still they
 # are included in the automatically generated help message)
@@ -XXX,XX +XXX,XX @@ for opt do
   ;;
   --disable-blobs) meson_option_parse --disable-install-blobs ""
   ;;
+  --enable-vfio-user-server) vfio_user_server="enabled"
+  ;;
+  --disable-vfio-user-server) vfio_user_server="disabled"
+  ;;
   --enable-tcmalloc) meson_option_parse --enable-malloc=tcmalloc tcmalloc
   ;;
   --enable-jemalloc) meson_option_parse --enable-malloc=jemalloc jemalloc
@@ -XXX,XX +XXX,XX @@ write_container_target_makefile() {
 
 
 
+##########################################
+# check for vfio_user_server
+
+case "$vfio_user_server" in
+  enabled )
+    if test "$git_submodules_action" != "ignore"; then
+      git_submodules="${git_submodules} subprojects/libvfio-user"
+    fi
+    ;;
+esac
+
 ##########################################
 # End of CC checks
 # After here, no more $cc or $ld runs
@@ -XXX,XX +XXX,XX @@ if test "$skip_meson" = no; then
   test "$slirp" != auto && meson_option_add "-Dslirp=$slirp"
   test "$smbd" != '' && meson_option_add "-Dsmbd=$smbd"
   test "$tcg" != enabled && meson_option_add "-Dtcg=$tcg"
+  test "$vfio_user_server" != auto && meson_option_add "-Dvfio_user_server=$vfio_user_server"
   run_meson() {
     NINJA=$ninja $meson setup --prefix "$prefix" "$@" $cross_arg "$PWD" "$source_path"
   }
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ multiprocess_allowed = get_option('multiprocess') \
   .require(targetos == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
   .allowed()
 
+vfio_user_server_allowed = get_option('vfio_user_server') \
+  .require(targetos == 'linux', error_message: 'vfio-user server is supported only on Linux') \
+  .allowed()
+
 have_tpm = get_option('tpm') \
   .require(targetos != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
   .allowed()
@@ -XXX,XX +XXX,XX @@ host_kconfig = \
   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
   (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
-  (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
+  (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
+  (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : [])
 
 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
 
@@ -XXX,XX +XXX,XX @@ if have_system
   endif
 endif
 
+libvfio_user_dep = not_found
+if have_system and vfio_user_server_allowed
+  have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build')
+
+  if not have_internal
+    error('libvfio-user source not found - please pull git submodule')
+  endif
+
+  libvfio_user_proj = subproject('libvfio-user')
+
+  libvfio_user_lib = libvfio_user_proj.get_variable('libvfio_user_dep')
+
+  libvfio_user_dep = declare_dependency(dependencies: [libvfio_user_lib])
+endif
+
 fdt = not_found
 if have_system
   fdt_opt = get_option('fdt')
@@ -XXX,XX +XXX,XX @@ summary_info += {'target list':       ' '.join(target_dirs)}
 if have_system
   summary_info += {'default devices':   get_option('default_devices')}
   summary_info += {'out of process emulation': multiprocess_allowed}
+  summary_info += {'vfio-user server': vfio_user_server_allowed}
 endif
 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
 
diff --git a/.gitlab-ci.d/buildtest.yml b/.gitlab-ci.d/buildtest.yml
index XXXXXXX..XXXXXXX 100644
--- a/.gitlab-ci.d/buildtest.yml
+++ b/.gitlab-ci.d/buildtest.yml
@@ -XXX,XX +XXX,XX @@ build-system-centos:
     IMAGE: centos8
     CONFIGURE_ARGS: --disable-nettle --enable-gcrypt --enable-fdt=system
       --enable-modules --enable-trace-backends=dtrace --enable-docs
+      --enable-vfio-user-server
     TARGETS: ppc64-softmmu or1k-softmmu s390x-softmmu
       x86_64-softmmu rx-softmmu sh4-softmmu nios2-softmmu
     MAKE_CHECK_ARGS: check-build
diff --git a/.gitmodules b/.gitmodules
index XXXXXXX..XXXXXXX 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -XXX,XX +XXX,XX @@
 [submodule "tests/lcitool/libvirt-ci"]
 	path = tests/lcitool/libvirt-ci
 	url = https://gitlab.com/libvirt/libvirt-ci.git
+[submodule "subprojects/libvfio-user"]
+	path = subprojects/libvfio-user
+	url = https://gitlab.com/qemu-project/libvfio-user.git
diff --git a/Kconfig.host b/Kconfig.host
index XXXXXXX..XXXXXXX 100644
--- a/Kconfig.host
+++ b/Kconfig.host
@@ -XXX,XX +XXX,XX @@ config MULTIPROCESS_ALLOWED
 config FUZZ
     bool
     select SPARSE_MEM
+
+config VFIO_USER_SERVER_ALLOWED
+    bool
+    imply VFIO_USER_SERVER
diff --git a/hw/remote/Kconfig b/hw/remote/Kconfig
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/Kconfig
+++ b/hw/remote/Kconfig
@@ -XXX,XX +XXX,XX @@ config MULTIPROCESS
     bool
     depends on PCI && PCI_EXPRESS && KVM
     select REMOTE_PCIHOST
+
+config VFIO_USER_SERVER
+    bool
+    depends on MULTIPROCESS
diff --git a/hw/remote/meson.build b/hw/remote/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/meson.build
+++ b/hw/remote/meson.build
@@ -XXX,XX +XXX,XX @@ remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('remote-obj.c'))
 remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('proxy.c'))
 remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('iohub.c'))
 
+remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: libvfio_user_dep)
+
 specific_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('memory.c'))
 specific_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('proxy-memory-listener.c'))
 
diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
index XXXXXXX..XXXXXXX 100644
--- a/scripts/meson-buildoptions.sh
+++ b/scripts/meson-buildoptions.sh
@@ -XXX,XX +XXX,XX @@ meson_options_help() {
   printf "%s\n" '  usb-redir       libusbredir support'
   printf "%s\n" '  vde             vde network backend support'
   printf "%s\n" '  vdi             vdi image format support'
+  printf "%s\n" '  vfio-user-server'
+  printf "%s\n" '                  vfio-user server support'
   printf "%s\n" '  vhost-crypto    vhost-user crypto backend support'
   printf "%s\n" '  vhost-kernel    vhost kernel backend support'
   printf "%s\n" '  vhost-net       vhost-net kernel acceleration support'
@@ -XXX,XX +XXX,XX @@ _meson_option_parse() {
     --disable-vde) printf "%s" -Dvde=disabled ;;
     --enable-vdi) printf "%s" -Dvdi=enabled ;;
     --disable-vdi) printf "%s" -Dvdi=disabled ;;
+    --enable-vfio-user-server) printf "%s" -Dvfio_user_server=enabled ;;
+    --disable-vfio-user-server) printf "%s" -Dvfio_user_server=disabled ;;
     --enable-vhost-crypto) printf "%s" -Dvhost_crypto=enabled ;;
     --disable-vhost-crypto) printf "%s" -Dvhost_crypto=disabled ;;
     --enable-vhost-kernel) printf "%s" -Dvhost_kernel=enabled ;;
diff --git a/subprojects/libvfio-user b/subprojects/libvfio-user
new file mode 160000
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/subprojects/libvfio-user
@@ -0,0 +1 @@
+Subproject commit 0b28d205572c80b568a1003db2c8f37ca333e4d7
diff --git a/tests/docker/dockerfiles/centos8.docker b/tests/docker/dockerfiles/centos8.docker
index XXXXXXX..XXXXXXX 100644
--- a/tests/docker/dockerfiles/centos8.docker
+++ b/tests/docker/dockerfiles/centos8.docker
@@ -XXX,XX +XXX,XX @@ RUN dnf update -y && \
         libbpf-devel \
         libcacard-devel \
         libcap-ng-devel \
+        libcmocka-devel \
         libcurl-devel \
         libdrm-devel \
         libepoxy-devel \
@@ -XXX,XX +XXX,XX @@ RUN dnf update -y && \
         libgcrypt-devel \
         libiscsi-devel \
         libjpeg-devel \
+        json-c-devel \
         libnfs-devel \
         libpmem-devel \
         libpng-devel \
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Define vfio-user object which is remote process server for QEMU. Setup
object initialization functions and properties necessary to instantiate
the object

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: e45a17001e9b38f451543a664ababdf860e5f2f2.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS                 |   1 +
 qapi/qom.json               |  20 +++-
 include/hw/remote/machine.h |   2 +
 hw/remote/machine.c         |  27 +++++
 hw/remote/vfio-user-obj.c   | 210 ++++++++++++++++++++++++++++++++++++
 hw/remote/meson.build       |   1 +
 hw/remote/trace-events      |   3 +
 7 files changed, 262 insertions(+), 2 deletions(-)
 create mode 100644 hw/remote/vfio-user-obj.c

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: include/hw/remote/proxy-memory-listener.h
 F: hw/remote/iohub.c
 F: include/hw/remote/iohub.h
 F: subprojects/libvfio-user
+F: hw/remote/vfio-user-obj.c
 
 EBPF:
 M: Jason Wang <jasowang@redhat.com>
diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
 { 'struct': 'RemoteObjectProperties',
   'data': { 'fd': 'str', 'devid': 'str' } }
 
+##
+# @VfioUserServerProperties:
+#
+# Properties for x-vfio-user-server objects.
+#
+# @socket: socket to be used by the libvfio-user library
+#
+# @device: the ID of the device to be emulated at the server
+#
+# Since: 7.1
+##
+{ 'struct': 'VfioUserServerProperties',
+  'data': { 'socket': 'SocketAddress', 'device': 'str' } }
+
 ##
 # @RngProperties:
 #
@@ -XXX,XX +XXX,XX @@
     'tls-creds-psk',
     'tls-creds-x509',
     'tls-cipher-suites',
-    { 'name': 'x-remote-object', 'features': [ 'unstable' ] }
+    { 'name': 'x-remote-object', 'features': [ 'unstable' ] },
+    { 'name': 'x-vfio-user-server', 'features': [ 'unstable' ] }
   ] }
 
 ##
@@ -XXX,XX +XXX,XX @@
       'tls-creds-psk':              'TlsCredsPskProperties',
       'tls-creds-x509':             'TlsCredsX509Properties',
       'tls-cipher-suites':          'TlsCredsProperties',
-      'x-remote-object':            'RemoteObjectProperties'
+      'x-remote-object':            'RemoteObjectProperties',
+      'x-vfio-user-server':         'VfioUserServerProperties'
   } }
 
 ##
diff --git a/include/hw/remote/machine.h b/include/hw/remote/machine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/remote/machine.h
+++ b/include/hw/remote/machine.h
@@ -XXX,XX +XXX,XX @@ struct RemoteMachineState {
     RemoteIOHubState iohub;
 
     bool vfio_user;
+
+    bool auto_shutdown;
 };
 
 /* Used to pass to co-routine device and ioc. */
diff --git a/hw/remote/machine.c b/hw/remote/machine.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/machine.c
+++ b/hw/remote/machine.c
@@ -XXX,XX +XXX,XX @@ static void remote_machine_set_vfio_user(Object *obj, bool value, Error **errp)
     s->vfio_user = value;
 }
 
+static bool remote_machine_get_auto_shutdown(Object *obj, Error **errp)
+{
+    RemoteMachineState *s = REMOTE_MACHINE(obj);
+
+    return s->auto_shutdown;
+}
+
+static void remote_machine_set_auto_shutdown(Object *obj, bool value,
+                                             Error **errp)
+{
+    RemoteMachineState *s = REMOTE_MACHINE(obj);
+
+    s->auto_shutdown = value;
+}
+
+static void remote_machine_instance_init(Object *obj)
+{
+    RemoteMachineState *s = REMOTE_MACHINE(obj);
+
+    s->auto_shutdown = true;
+}
+
 static void remote_machine_class_init(ObjectClass *oc, void *data)
 {
     MachineClass *mc = MACHINE_CLASS(oc);
@@ -XXX,XX +XXX,XX @@ static void remote_machine_class_init(ObjectClass *oc, void *data)
     object_class_property_add_bool(oc, "vfio-user",
                                    remote_machine_get_vfio_user,
                                    remote_machine_set_vfio_user);
+
+    object_class_property_add_bool(oc, "auto-shutdown",
+                                   remote_machine_get_auto_shutdown,
+                                   remote_machine_set_auto_shutdown);
 }
 
 static const TypeInfo remote_machine = {
     .name = TYPE_REMOTE_MACHINE,
     .parent = TYPE_MACHINE,
     .instance_size = sizeof(RemoteMachineState),
+    .instance_init = remote_machine_instance_init,
     .class_init = remote_machine_class_init,
     .interfaces = (InterfaceInfo[]) {
         { TYPE_HOTPLUG_HANDLER },
diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
+/**
+ * QEMU vfio-user-server server object
+ *
+ * Copyright © 2022 Oracle and/or its affiliates.
+ *
+ * This work is licensed under the terms of the GNU GPL-v2, version 2 or later.
+ *
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+/**
+ * Usage: add options:
+ *     -machine x-remote,vfio-user=on,auto-shutdown=on
+ *     -device <PCI-device>,id=<pci-dev-id>
+ *     -object x-vfio-user-server,id=<id>,type=unix,path=<socket-path>,
+ *             device=<pci-dev-id>
+ *
+ * Note that x-vfio-user-server object must be used with x-remote machine only.
+ * This server could only support PCI devices for now.
+ *
+ * type - SocketAddress type - presently "unix" alone is supported. Required
+ *        option
+ *
+ * path - named unix socket, it will be created by the server. It is
+ *        a required option
+ *
+ * device - id of a device on the server, a required option. PCI devices
+ *          alone are supported presently.
+ */
+
+#include "qemu/osdep.h"
+
+#include "qom/object.h"
+#include "qom/object_interfaces.h"
+#include "qemu/error-report.h"
+#include "trace.h"
+#include "sysemu/runstate.h"
+#include "hw/boards.h"
+#include "hw/remote/machine.h"
+#include "qapi/error.h"
+#include "qapi/qapi-visit-sockets.h"
+
+#define TYPE_VFU_OBJECT "x-vfio-user-server"
+OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
+
+/**
+ * VFU_OBJECT_ERROR - reports an error message. If auto_shutdown
+ * is set, it aborts the machine on error. Otherwise, it logs an
+ * error message without aborting.
+ */
+#define VFU_OBJECT_ERROR(o, fmt, ...)                                     \
+    {                                                                     \
+        if (vfu_object_auto_shutdown()) {                                 \
+            error_setg(&error_abort, (fmt), ## __VA_ARGS__);              \
+        } else {                                                          \
+            error_report((fmt), ## __VA_ARGS__);                          \
+        }                                                                 \
+    }                                                                     \
+
+struct VfuObjectClass {
+    ObjectClass parent_class;
+
+    unsigned int nr_devs;
+};
+
+struct VfuObject {
+    /* private */
+    Object parent;
+
+    SocketAddress *socket;
+
+    char *device;
+
+    Error *err;
+};
+
+static bool vfu_object_auto_shutdown(void)
+{
+    bool auto_shutdown = true;
+    Error *local_err = NULL;
+
+    if (!current_machine) {
+        return auto_shutdown;
+    }
+
+    auto_shutdown = object_property_get_bool(OBJECT(current_machine),
+                                             "auto-shutdown",
+                                             &local_err);
+
+    /*
+     * local_err would be set if no such property exists - safe to ignore.
+     * Unlikely scenario as auto-shutdown is always defined for
+     * TYPE_REMOTE_MACHINE, and  TYPE_VFU_OBJECT only works with
+     * TYPE_REMOTE_MACHINE
+     */
+    if (local_err) {
+        auto_shutdown = true;
+        error_free(local_err);
+    }
+
+    return auto_shutdown;
+}
+
+static void vfu_object_set_socket(Object *obj, Visitor *v, const char *name,
+                                  void *opaque, Error **errp)
+{
+    VfuObject *o = VFU_OBJECT(obj);
+
+    qapi_free_SocketAddress(o->socket);
+
+    o->socket = NULL;
+
+    visit_type_SocketAddress(v, name, &o->socket, errp);
+
+    if (o->socket->type != SOCKET_ADDRESS_TYPE_UNIX) {
+        error_setg(errp, "vfu: Unsupported socket type - %s",
+                   SocketAddressType_str(o->socket->type));
+        qapi_free_SocketAddress(o->socket);
+        o->socket = NULL;
+        return;
+    }
+
+    trace_vfu_prop("socket", o->socket->u.q_unix.path);
+}
+
+static void vfu_object_set_device(Object *obj, const char *str, Error **errp)
+{
+    VfuObject *o = VFU_OBJECT(obj);
+
+    g_free(o->device);
+
+    o->device = g_strdup(str);
+
+    trace_vfu_prop("device", str);
+}
+
+static void vfu_object_init(Object *obj)
+{
+    VfuObjectClass *k = VFU_OBJECT_GET_CLASS(obj);
+    VfuObject *o = VFU_OBJECT(obj);
+
+    k->nr_devs++;
+
+    if (!object_dynamic_cast(OBJECT(current_machine), TYPE_REMOTE_MACHINE)) {
+        error_setg(&o->err, "vfu: %s only compatible with %s machine",
+                   TYPE_VFU_OBJECT, TYPE_REMOTE_MACHINE);
+        return;
+    }
+}
+
+static void vfu_object_finalize(Object *obj)
+{
+    VfuObjectClass *k = VFU_OBJECT_GET_CLASS(obj);
+    VfuObject *o = VFU_OBJECT(obj);
+
+    k->nr_devs--;
+
+    qapi_free_SocketAddress(o->socket);
+
+    o->socket = NULL;
+
+    g_free(o->device);
+
+    o->device = NULL;
+
+    if (!k->nr_devs && vfu_object_auto_shutdown()) {
+        qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
+    }
+}
+
+static void vfu_object_class_init(ObjectClass *klass, void *data)
+{
+    VfuObjectClass *k = VFU_OBJECT_CLASS(klass);
+
+    k->nr_devs = 0;
+
+    object_class_property_add(klass, "socket", "SocketAddress", NULL,
+                              vfu_object_set_socket, NULL, NULL);
+    object_class_property_set_description(klass, "socket",
+                                          "SocketAddress "
+                                          "(ex: type=unix,path=/tmp/sock). "
+                                          "Only UNIX is presently supported");
+    object_class_property_add_str(klass, "device", NULL,
+                                  vfu_object_set_device);
+    object_class_property_set_description(klass, "device",
+                                          "device ID - only PCI devices "
+                                          "are presently supported");
+}
+
+static const TypeInfo vfu_object_info = {
+    .name = TYPE_VFU_OBJECT,
+    .parent = TYPE_OBJECT,
+    .instance_size = sizeof(VfuObject),
+    .instance_init = vfu_object_init,
+    .instance_finalize = vfu_object_finalize,
+    .class_size = sizeof(VfuObjectClass),
+    .class_init = vfu_object_class_init,
+    .interfaces = (InterfaceInfo[]) {
+        { TYPE_USER_CREATABLE },
+        { }
+    }
+};
+
+static void vfu_register_types(void)
+{
+    type_register_static(&vfu_object_info);
+}
+
+type_init(vfu_register_types);
diff --git a/hw/remote/meson.build b/hw/remote/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/meson.build
+++ b/hw/remote/meson.build
@@ -XXX,XX +XXX,XX @@ remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('message.c'))
 remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('remote-obj.c'))
 remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('proxy.c'))
 remote_ss.add(when: 'CONFIG_MULTIPROCESS', if_true: files('iohub.c'))
+remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: files('vfio-user-obj.c'))
 
 remote_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_true: libvfio_user_dep)
 
diff --git a/hw/remote/trace-events b/hw/remote/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/trace-events
+++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@
 
 mpqemu_send_io_error(int cmd, int size, int nfds) "send command %d size %d, %d file descriptors to remote process"
 mpqemu_recv_io_error(int cmd, int size, int nfds) "failed to receive %d size %d, %d file descriptors to remote process"
+
+# vfio-user-obj.c
+vfu_prop(const char *prop, const char *val) "vfu: setting %s as %s"
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

create a context with the vfio-user library to run a PCI device

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: a452871ac8c812ff96fc4f0ce6037f4769953fab.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/remote/vfio-user-obj.c | 82 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/remote/machine.h"
 #include "qapi/error.h"
 #include "qapi/qapi-visit-sockets.h"
+#include "qemu/notify.h"
+#include "sysemu/sysemu.h"
+#include "libvfio-user.h"
 
 #define TYPE_VFU_OBJECT "x-vfio-user-server"
 OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
@@ -XXX,XX +XXX,XX @@ struct VfuObject {
     char *device;
 
     Error *err;
+
+    Notifier machine_done;
+
+    vfu_ctx_t *vfu_ctx;
 };
 
+static void vfu_object_init_ctx(VfuObject *o, Error **errp);
+
 static bool vfu_object_auto_shutdown(void)
 {
     bool auto_shutdown = true;
@@ -XXX,XX +XXX,XX @@ static void vfu_object_set_socket(Object *obj, Visitor *v, const char *name,
 {
     VfuObject *o = VFU_OBJECT(obj);
 
+    if (o->vfu_ctx) {
+        error_setg(errp, "vfu: Unable to set socket property - server busy");
+        return;
+    }
+
     qapi_free_SocketAddress(o->socket);
 
     o->socket = NULL;
@@ -XXX,XX +XXX,XX @@ static void vfu_object_set_socket(Object *obj, Visitor *v, const char *name,
     }
 
     trace_vfu_prop("socket", o->socket->u.q_unix.path);
+
+    vfu_object_init_ctx(o, errp);
 }
 
 static void vfu_object_set_device(Object *obj, const char *str, Error **errp)
 {
     VfuObject *o = VFU_OBJECT(obj);
 
+    if (o->vfu_ctx) {
+        error_setg(errp, "vfu: Unable to set device property - server busy");
+        return;
+    }
+
     g_free(o->device);
 
     o->device = g_strdup(str);
 
     trace_vfu_prop("device", str);
+
+    vfu_object_init_ctx(o, errp);
+}
+
+/*
+ * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
+ * properties. It also depends on devices instantiated in QEMU. These
+ * dependencies are not available during the instance_init phase of this
+ * object's life-cycle. As such, the server is initialized after the
+ * machine is setup. machine_init_done_notifier notifies TYPE_VFU_OBJECT
+ * when the machine is setup, and the dependencies are available.
+ */
+static void vfu_object_machine_done(Notifier *notifier, void *data)
+{
+    VfuObject *o = container_of(notifier, VfuObject, machine_done);
+    Error *err = NULL;
+
+    vfu_object_init_ctx(o, &err);
+
+    if (err) {
+        error_propagate(&error_abort, err);
+    }
+}
+
+static void vfu_object_init_ctx(VfuObject *o, Error **errp)
+{
+    ERRP_GUARD();
+
+    if (o->vfu_ctx || !o->socket || !o->device ||
+            !phase_check(PHASE_MACHINE_READY)) {
+        return;
+    }
+
+    if (o->err) {
+        error_propagate(errp, o->err);
+        o->err = NULL;
+        return;
+    }
+
+    o->vfu_ctx = vfu_create_ctx(VFU_TRANS_SOCK, o->socket->u.q_unix.path, 0,
+                                o, VFU_DEV_TYPE_PCI);
+    if (o->vfu_ctx == NULL) {
+        error_setg(errp, "vfu: Failed to create context - %s", strerror(errno));
+        return;
+    }
 }
 
 static void vfu_object_init(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init(Object *obj)
                    TYPE_VFU_OBJECT, TYPE_REMOTE_MACHINE);
         return;
     }
+
+    if (!phase_check(PHASE_MACHINE_READY)) {
+        o->machine_done.notify = vfu_object_machine_done;
+        qemu_add_machine_init_done_notifier(&o->machine_done);
+    }
+
 }
 
 static void vfu_object_finalize(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
 
     o->socket = NULL;
 
+    if (o->vfu_ctx) {
+        vfu_destroy_ctx(o->vfu_ctx);
+        o->vfu_ctx = NULL;
+    }
+
     g_free(o->device);
 
     o->device = NULL;
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
     if (!k->nr_devs && vfu_object_auto_shutdown()) {
         qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
     }
+
+    if (o->machine_done.notify) {
+        qemu_remove_machine_init_done_notifier(&o->machine_done);
+        o->machine_done.notify = NULL;
+    }
 }
 
 static void vfu_object_class_init(ObjectClass *klass, void *data)
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Find the PCI device with specified id. Initialize the device context
with the QEMU PCI device

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 7798dbd730099b33fdd00c4c202cfe79e5c5c151.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/remote/vfio-user-obj.c | 67 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/notify.h"
 #include "sysemu/sysemu.h"
 #include "libvfio-user.h"
+#include "hw/qdev-core.h"
+#include "hw/pci/pci.h"
 
 #define TYPE_VFU_OBJECT "x-vfio-user-server"
 OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
@@ -XXX,XX +XXX,XX @@ struct VfuObject {
     Notifier machine_done;
 
     vfu_ctx_t *vfu_ctx;
+
+    PCIDevice *pci_dev;
+
+    Error *unplug_blocker;
 };
 
 static void vfu_object_init_ctx(VfuObject *o, Error **errp);
@@ -XXX,XX +XXX,XX @@ static void vfu_object_machine_done(Notifier *notifier, void *data)
 static void vfu_object_init_ctx(VfuObject *o, Error **errp)
 {
     ERRP_GUARD();
+    DeviceState *dev = NULL;
+    vfu_pci_type_t pci_type = VFU_PCI_TYPE_CONVENTIONAL;
+    int ret;
 
     if (o->vfu_ctx || !o->socket || !o->device ||
             !phase_check(PHASE_MACHINE_READY)) {
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
         error_setg(errp, "vfu: Failed to create context - %s", strerror(errno));
         return;
     }
+
+    dev = qdev_find_recursive(sysbus_get_default(), o->device);
+    if (dev == NULL) {
+        error_setg(errp, "vfu: Device %s not found", o->device);
+        goto fail;
+    }
+
+    if (!object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
+        error_setg(errp, "vfu: %s not a PCI device", o->device);
+        goto fail;
+    }
+
+    o->pci_dev = PCI_DEVICE(dev);
+
+    object_ref(OBJECT(o->pci_dev));
+
+    if (pci_is_express(o->pci_dev)) {
+        pci_type = VFU_PCI_TYPE_EXPRESS;
+    }
+
+    ret = vfu_pci_init(o->vfu_ctx, pci_type, PCI_HEADER_TYPE_NORMAL, 0);
+    if (ret < 0) {
+        error_setg(errp,
+                   "vfu: Failed to attach PCI device %s to context - %s",
+                   o->device, strerror(errno));
+        goto fail;
+    }
+
+    error_setg(&o->unplug_blocker,
+               "vfu: %s for %s must be deleted before unplugging",
+               TYPE_VFU_OBJECT, o->device);
+    qdev_add_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
+
+    return;
+
+fail:
+    vfu_destroy_ctx(o->vfu_ctx);
+    if (o->unplug_blocker && o->pci_dev) {
+        qdev_del_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
+        error_free(o->unplug_blocker);
+        o->unplug_blocker = NULL;
+    }
+    if (o->pci_dev) {
+        object_unref(OBJECT(o->pci_dev));
+        o->pci_dev = NULL;
+    }
+    o->vfu_ctx = NULL;
 }
 
 static void vfu_object_init(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
 
     o->device = NULL;
 
+    if (o->unplug_blocker && o->pci_dev) {
+        qdev_del_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
+        error_free(o->unplug_blocker);
+        o->unplug_blocker = NULL;
+    }
+
+    if (o->pci_dev) {
+        object_unref(OBJECT(o->pci_dev));
+        o->pci_dev = NULL;
+    }
+
     if (!k->nr_devs && vfu_object_auto_shutdown()) {
         qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
     }
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Setup a handler to run vfio-user context. The context is driven by
messages to the file descriptor associated with it - get the fd for
the context and hook up the handler with it

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: e934b0090529d448b6a7972b21dfc3d7421ce494.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/misc.json            |  31 ++++++++++
 hw/remote/vfio-user-obj.c | 118 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 148 insertions(+), 1 deletion(-)

diff --git a/qapi/misc.json b/qapi/misc.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/misc.json
+++ b/qapi/misc.json
@@ -XXX,XX +XXX,XX @@
 ##
 { 'event': 'RTC_CHANGE',
   'data': { 'offset': 'int', 'qom-path': 'str' } }
+
+##
+# @VFU_CLIENT_HANGUP:
+#
+# Emitted when the client of a TYPE_VFIO_USER_SERVER closes the
+# communication channel
+#
+# @vfu-id: ID of the TYPE_VFIO_USER_SERVER object. It is the last component
+#          of @vfu-qom-path referenced below
+#
+# @vfu-qom-path: path to the TYPE_VFIO_USER_SERVER object in the QOM tree
+#
+# @dev-id: ID of attached PCI device
+#
+# @dev-qom-path: path to attached PCI device in the QOM tree
+#
+# Since: 7.1
+#
+# Example:
+#
+# <- { "event": "VFU_CLIENT_HANGUP",
+#      "data": { "vfu-id": "vfu1",
+#                "vfu-qom-path": "/objects/vfu1",
+#                "dev-id": "sas1",
+#                "dev-qom-path": "/machine/peripheral/sas1" },
+#      "timestamp": { "seconds": 1265044230, "microseconds": 450486 } }
+#
+##
+{ 'event': 'VFU_CLIENT_HANGUP',
+  'data': { 'vfu-id': 'str', 'vfu-qom-path': 'str',
+            'dev-id': 'str', 'dev-qom-path': 'str' } }
diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
  *
  * device - id of a device on the server, a required option. PCI devices
  *          alone are supported presently.
+ *
+ * notes - x-vfio-user-server could block IO and monitor during the
+ *         initialization phase.
  */
 
 #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@
 #include "hw/remote/machine.h"
 #include "qapi/error.h"
 #include "qapi/qapi-visit-sockets.h"
+#include "qapi/qapi-events-misc.h"
 #include "qemu/notify.h"
+#include "qemu/thread.h"
 #include "sysemu/sysemu.h"
 #include "libvfio-user.h"
 #include "hw/qdev-core.h"
 #include "hw/pci/pci.h"
+#include "qemu/timer.h"
 
 #define TYPE_VFU_OBJECT "x-vfio-user-server"
 OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
@@ -XXX,XX +XXX,XX @@ struct VfuObject {
     PCIDevice *pci_dev;
 
     Error *unplug_blocker;
+
+    int vfu_poll_fd;
 };
 
 static void vfu_object_init_ctx(VfuObject *o, Error **errp);
@@ -XXX,XX +XXX,XX @@ static void vfu_object_set_device(Object *obj, const char *str, Error **errp)
     vfu_object_init_ctx(o, errp);
 }
 
+static void vfu_object_ctx_run(void *opaque)
+{
+    VfuObject *o = opaque;
+    const char *vfu_id;
+    char *vfu_path, *pci_dev_path;
+    int ret = -1;
+
+    while (ret != 0) {
+        ret = vfu_run_ctx(o->vfu_ctx);
+        if (ret < 0) {
+            if (errno == EINTR) {
+                continue;
+            } else if (errno == ENOTCONN) {
+                vfu_id = object_get_canonical_path_component(OBJECT(o));
+                vfu_path = object_get_canonical_path(OBJECT(o));
+                g_assert(o->pci_dev);
+                pci_dev_path = object_get_canonical_path(OBJECT(o->pci_dev));
+                 /* o->device is a required property and is non-NULL here */
+                g_assert(o->device);
+                qapi_event_send_vfu_client_hangup(vfu_id, vfu_path,
+                                                  o->device, pci_dev_path);
+                qemu_set_fd_handler(o->vfu_poll_fd, NULL, NULL, NULL);
+                o->vfu_poll_fd = -1;
+                object_unparent(OBJECT(o));
+                g_free(vfu_path);
+                g_free(pci_dev_path);
+                break;
+            } else {
+                VFU_OBJECT_ERROR(o, "vfu: Failed to run device %s - %s",
+                                 o->device, strerror(errno));
+                break;
+            }
+        }
+    }
+}
+
+static void vfu_object_attach_ctx(void *opaque)
+{
+    VfuObject *o = opaque;
+    GPollFD pfds[1];
+    int ret;
+
+    qemu_set_fd_handler(o->vfu_poll_fd, NULL, NULL, NULL);
+
+    pfds[0].fd = o->vfu_poll_fd;
+    pfds[0].events = G_IO_IN | G_IO_HUP | G_IO_ERR;
+
+retry_attach:
+    ret = vfu_attach_ctx(o->vfu_ctx);
+    if (ret < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
+        /**
+         * vfu_object_attach_ctx can block QEMU's main loop
+         * during attach - the monitor and other IO
+         * could be unresponsive during this time.
+         */
+        (void)qemu_poll_ns(pfds, 1, 500 * (int64_t)SCALE_MS);
+        goto retry_attach;
+    } else if (ret < 0) {
+        VFU_OBJECT_ERROR(o, "vfu: Failed to attach device %s to context - %s",
+                         o->device, strerror(errno));
+        return;
+    }
+
+    o->vfu_poll_fd = vfu_get_poll_fd(o->vfu_ctx);
+    if (o->vfu_poll_fd < 0) {
+        VFU_OBJECT_ERROR(o, "vfu: Failed to get poll fd %s", o->device);
+        return;
+    }
+
+    qemu_set_fd_handler(o->vfu_poll_fd, vfu_object_ctx_run, NULL, o);
+}
+
 /*
  * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
  * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_machine_done(Notifier *notifier, void *data)
     }
 }
 
+/**
+ * vfu_object_init_ctx: Create and initialize libvfio-user context. Add
+ *     an unplug blocker for the associated PCI device. Setup a FD handler
+ *     to process incoming messages in the context's socket.
+ *
+ *     The socket and device properties are mandatory, and this function
+ *     will not create the context without them - the setters for these
+ *     properties should call this function when the property is set. The
+ *     machine should also be ready when this function is invoked - it is
+ *     because QEMU objects are initialized before devices, and the
+ *     associated PCI device wouldn't be available at the object
+ *     initialization time. Until these conditions are satisfied, this
+ *     function would return early without performing any task.
+ */
 static void vfu_object_init_ctx(VfuObject *o, Error **errp)
 {
     ERRP_GUARD();
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
         return;
     }
 
-    o->vfu_ctx = vfu_create_ctx(VFU_TRANS_SOCK, o->socket->u.q_unix.path, 0,
+    o->vfu_ctx = vfu_create_ctx(VFU_TRANS_SOCK, o->socket->u.q_unix.path,
+                                LIBVFIO_USER_FLAG_ATTACH_NB,
                                 o, VFU_DEV_TYPE_PCI);
     if (o->vfu_ctx == NULL) {
         error_setg(errp, "vfu: Failed to create context - %s", strerror(errno));
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
                TYPE_VFU_OBJECT, o->device);
     qdev_add_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
 
+    ret = vfu_realize_ctx(o->vfu_ctx);
+    if (ret < 0) {
+        error_setg(errp, "vfu: Failed to realize device %s- %s",
+                   o->device, strerror(errno));
+        goto fail;
+    }
+
+    o->vfu_poll_fd = vfu_get_poll_fd(o->vfu_ctx);
+    if (o->vfu_poll_fd < 0) {
+        error_setg(errp, "vfu: Failed to get poll fd %s", o->device);
+        goto fail;
+    }
+
+    qemu_set_fd_handler(o->vfu_poll_fd, vfu_object_attach_ctx, NULL, o);
+
     return;
 
 fail:
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init(Object *obj)
         qemu_add_machine_init_done_notifier(&o->machine_done);
     }
 
+    o->vfu_poll_fd = -1;
 }
 
 static void vfu_object_finalize(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
 
     o->socket = NULL;
 
+    if (o->vfu_poll_fd != -1) {
+        qemu_set_fd_handler(o->vfu_poll_fd, NULL, NULL, NULL);
+        o->vfu_poll_fd = -1;
+    }
+
     if (o->vfu_ctx) {
         vfu_destroy_ctx(o->vfu_ctx);
         o->vfu_ctx = NULL;
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Define and register handlers for PCI config space accesses

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: be9d2ccf9b1d24e50dcd9c23404dbf284142cec7.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/remote/vfio-user-obj.c | 51 +++++++++++++++++++++++++++++++++++++++
 hw/remote/trace-events    |  2 ++
 2 files changed, 53 insertions(+)

diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qapi-events-misc.h"
 #include "qemu/notify.h"
 #include "qemu/thread.h"
+#include "qemu/main-loop.h"
 #include "sysemu/sysemu.h"
 #include "libvfio-user.h"
 #include "hw/qdev-core.h"
@@ -XXX,XX +XXX,XX @@ retry_attach:
     qemu_set_fd_handler(o->vfu_poll_fd, vfu_object_ctx_run, NULL, o);
 }
 
+static ssize_t vfu_object_cfg_access(vfu_ctx_t *vfu_ctx, char * const buf,
+                                     size_t count, loff_t offset,
+                                     const bool is_write)
+{
+    VfuObject *o = vfu_get_private(vfu_ctx);
+    uint32_t pci_access_width = sizeof(uint32_t);
+    size_t bytes = count;
+    uint32_t val = 0;
+    char *ptr = buf;
+    int len;
+
+    /*
+     * Writes to the BAR registers would trigger an update to the
+     * global Memory and IO AddressSpaces. But the remote device
+     * never uses the global AddressSpaces, therefore overlapping
+     * memory regions are not a problem
+     */
+    while (bytes > 0) {
+        len = (bytes > pci_access_width) ? pci_access_width : bytes;
+        if (is_write) {
+            memcpy(&val, ptr, len);
+            pci_host_config_write_common(o->pci_dev, offset,
+                                         pci_config_size(o->pci_dev),
+                                         val, len);
+            trace_vfu_cfg_write(offset, val);
+        } else {
+            val = pci_host_config_read_common(o->pci_dev, offset,
+                                              pci_config_size(o->pci_dev), len);
+            memcpy(ptr, &val, len);
+            trace_vfu_cfg_read(offset, val);
+        }
+        offset += len;
+        ptr += len;
+        bytes -= len;
+    }
+
+    return count;
+}
+
 /*
  * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
  * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
                TYPE_VFU_OBJECT, o->device);
     qdev_add_unplug_blocker(DEVICE(o->pci_dev), o->unplug_blocker);
 
+    ret = vfu_setup_region(o->vfu_ctx, VFU_PCI_DEV_CFG_REGION_IDX,
+                           pci_config_size(o->pci_dev), &vfu_object_cfg_access,
+                           VFU_REGION_FLAG_RW | VFU_REGION_FLAG_ALWAYS_CB,
+                           NULL, 0, -1, 0);
+    if (ret < 0) {
+        error_setg(errp,
+                   "vfu: Failed to setup config space handlers for %s- %s",
+                   o->device, strerror(errno));
+        goto fail;
+    }
+
     ret = vfu_realize_ctx(o->vfu_ctx);
     if (ret < 0) {
         error_setg(errp, "vfu: Failed to realize device %s- %s",
diff --git a/hw/remote/trace-events b/hw/remote/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/trace-events
+++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@ mpqemu_recv_io_error(int cmd, int size, int nfds) "failed to receive %d size %d,
 
 # vfio-user-obj.c
 vfu_prop(const char *prop, const char *val) "vfu: setting %s as %s"
+vfu_cfg_read(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u -> 0x%x"
+vfu_cfg_write(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u <- 0x%x"
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Assign separate address space for each device in the remote processes.

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: afe0b0a97582cdad42b5b25636a29c523265a10a.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS               |   2 +
 include/hw/remote/iommu.h |  40 ++++++++++++
 hw/remote/iommu.c         | 131 ++++++++++++++++++++++++++++++++++++++
 hw/remote/machine.c       |  13 +++-
 hw/remote/meson.build     |   1 +
 5 files changed, 186 insertions(+), 1 deletion(-)
 create mode 100644 include/hw/remote/iommu.h
 create mode 100644 hw/remote/iommu.c

From: Jagannathan Raman <jag.raman@oracle.com>

Define and register callbacks to manage the RAM regions used for
device DMA

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: faacbcd45c4d02c591f0dbfdc19041fbb3eae7eb.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/remote/machine.c       |  5 ++++
 hw/remote/vfio-user-obj.c | 55 +++++++++++++++++++++++++++++++++++++++
 hw/remote/trace-events    |  2 ++
 3 files changed, 62 insertions(+)

diff --git a/hw/remote/machine.c b/hw/remote/machine.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/machine.c
+++ b/hw/remote/machine.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/remote/iohub.h"
 #include "hw/remote/iommu.h"
 #include "hw/qdev-core.h"
+#include "hw/remote/iommu.h"
 
 static void remote_machine_init(MachineState *machine)
 {
@@ -XXX,XX +XXX,XX @@ static void remote_machine_init(MachineState *machine)
 
     pci_host = PCI_HOST_BRIDGE(rem_host);
 
+    if (s->vfio_user) {
+        remote_iommu_setup(pci_host->bus);
+    }
+
     remote_iohub_init(&s->iohub);
 
     pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, remote_iohub_map_irq,
diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@ static ssize_t vfu_object_cfg_access(vfu_ctx_t *vfu_ctx, char * const buf,
     return count;
 }
 
+static void dma_register(vfu_ctx_t *vfu_ctx, vfu_dma_info_t *info)
+{
+    VfuObject *o = vfu_get_private(vfu_ctx);
+    AddressSpace *dma_as = NULL;
+    MemoryRegion *subregion = NULL;
+    g_autofree char *name = NULL;
+    struct iovec *iov = &info->iova;
+
+    if (!info->vaddr) {
+        return;
+    }
+
+    name = g_strdup_printf("mem-%s-%"PRIx64"", o->device,
+                           (uint64_t)info->vaddr);
+
+    subregion = g_new0(MemoryRegion, 1);
+
+    memory_region_init_ram_ptr(subregion, NULL, name,
+                               iov->iov_len, info->vaddr);
+
+    dma_as = pci_device_iommu_address_space(o->pci_dev);
+
+    memory_region_add_subregion(dma_as->root, (hwaddr)iov->iov_base, subregion);
+
+    trace_vfu_dma_register((uint64_t)iov->iov_base, iov->iov_len);
+}
+
+static void dma_unregister(vfu_ctx_t *vfu_ctx, vfu_dma_info_t *info)
+{
+    VfuObject *o = vfu_get_private(vfu_ctx);
+    AddressSpace *dma_as = NULL;
+    MemoryRegion *mr = NULL;
+    ram_addr_t offset;
+
+    mr = memory_region_from_host(info->vaddr, &offset);
+    if (!mr) {
+        return;
+    }
+
+    dma_as = pci_device_iommu_address_space(o->pci_dev);
+
+    memory_region_del_subregion(dma_as->root, mr);
+
+    object_unparent((OBJECT(mr)));
+
+    trace_vfu_dma_unregister((uint64_t)info->iova.iov_base);
+}
+
 /*
  * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
  * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
         goto fail;
     }
 
+    ret = vfu_setup_device_dma(o->vfu_ctx, &dma_register, &dma_unregister);
+    if (ret < 0) {
+        error_setg(errp, "vfu: Failed to setup DMA handlers for %s",
+                   o->device);
+        goto fail;
+    }
+
     ret = vfu_realize_ctx(o->vfu_ctx);
     if (ret < 0) {
         error_setg(errp, "vfu: Failed to realize device %s- %s",
diff --git a/hw/remote/trace-events b/hw/remote/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/trace-events
+++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@ mpqemu_recv_io_error(int cmd, int size, int nfds) "failed to receive %d size %d,
 vfu_prop(const char *prop, const char *val) "vfu: setting %s as %s"
 vfu_cfg_read(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u -> 0x%x"
 vfu_cfg_write(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u <- 0x%x"
+vfu_dma_register(uint64_t gpa, size_t len) "vfu: registering GPA 0x%"PRIx64", %zu bytes"
+vfu_dma_unregister(uint64_t gpa) "vfu: unregistering GPA 0x%"PRIx64""
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Determine the BARs used by the PCI device and register handlers to
manage the access to the same.

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 3373e10b5be5f42846f0632d4382466e1698c505.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/exec/memory.h           |   3 +
 hw/remote/vfio-user-obj.c       | 190 ++++++++++++++++++++++++++++++++
 softmmu/physmem.c               |   4 +-
 tests/qtest/fuzz/generic_fuzz.c |   9 +-
 hw/remote/trace-events          |   3 +
 5 files changed, 203 insertions(+), 6 deletions(-)

diff --git a/include/exec/memory.h b/include/exec/memory.h
index XXXXXXX..XXXXXXX 100644
--- a/include/exec/memory.h
+++ b/include/exec/memory.h
@@ -XXX,XX +XXX,XX @@ MemTxResult address_space_write_cached_slow(MemoryRegionCache *cache,
                                             hwaddr addr, const void *buf,
                                             hwaddr len);
 
+int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr);
+bool prepare_mmio_access(MemoryRegion *mr);
+
 static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
 {
     if (is_write) {
diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/qdev-core.h"
 #include "hw/pci/pci.h"
 #include "qemu/timer.h"
+#include "exec/memory.h"
 
 #define TYPE_VFU_OBJECT "x-vfio-user-server"
 OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
@@ -XXX,XX +XXX,XX @@ static void dma_unregister(vfu_ctx_t *vfu_ctx, vfu_dma_info_t *info)
     trace_vfu_dma_unregister((uint64_t)info->iova.iov_base);
 }
 
+static int vfu_object_mr_rw(MemoryRegion *mr, uint8_t *buf, hwaddr offset,
+                            hwaddr size, const bool is_write)
+{
+    uint8_t *ptr = buf;
+    bool release_lock = false;
+    uint8_t *ram_ptr = NULL;
+    MemTxResult result;
+    int access_size;
+    uint64_t val;
+
+    if (memory_access_is_direct(mr, is_write)) {
+        /**
+         * Some devices expose a PCI expansion ROM, which could be buffer
+         * based as compared to other regions which are primarily based on
+         * MemoryRegionOps. memory_region_find() would already check
+         * for buffer overflow, we don't need to repeat it here.
+         */
+        ram_ptr = memory_region_get_ram_ptr(mr);
+
+        if (is_write) {
+            memcpy((ram_ptr + offset), buf, size);
+        } else {
+            memcpy(buf, (ram_ptr + offset), size);
+        }
+
+        return 0;
+    }
+
+    while (size) {
+        /**
+         * The read/write logic used below is similar to the ones in
+         * flatview_read/write_continue()
+         */
+        release_lock = prepare_mmio_access(mr);
+
+        access_size = memory_access_size(mr, size, offset);
+
+        if (is_write) {
+            val = ldn_he_p(ptr, access_size);
+
+            result = memory_region_dispatch_write(mr, offset, val,
+                                                  size_memop(access_size),
+                                                  MEMTXATTRS_UNSPECIFIED);
+        } else {
+            result = memory_region_dispatch_read(mr, offset, &val,
+                                                 size_memop(access_size),
+                                                 MEMTXATTRS_UNSPECIFIED);
+
+            stn_he_p(ptr, access_size, val);
+        }
+
+        if (release_lock) {
+            qemu_mutex_unlock_iothread();
+            release_lock = false;
+        }
+
+        if (result != MEMTX_OK) {
+            return -1;
+        }
+
+        size -= access_size;
+        ptr += access_size;
+        offset += access_size;
+    }
+
+    return 0;
+}
+
+static size_t vfu_object_bar_rw(PCIDevice *pci_dev, int pci_bar,
+                                hwaddr bar_offset, char * const buf,
+                                hwaddr len, const bool is_write)
+{
+    MemoryRegionSection section = { 0 };
+    uint8_t *ptr = (uint8_t *)buf;
+    MemoryRegion *section_mr = NULL;
+    uint64_t section_size;
+    hwaddr section_offset;
+    hwaddr size = 0;
+
+    while (len) {
+        section = memory_region_find(pci_dev->io_regions[pci_bar].memory,
+                                     bar_offset, len);
+
+        if (!section.mr) {
+            warn_report("vfu: invalid address 0x%"PRIx64"", bar_offset);
+            return size;
+        }
+
+        section_mr = section.mr;
+        section_offset = section.offset_within_region;
+        section_size = int128_get64(section.size);
+
+        if (is_write && section_mr->readonly) {
+            warn_report("vfu: attempting to write to readonly region in "
+                        "bar %d - [0x%"PRIx64" - 0x%"PRIx64"]",
+                        pci_bar, bar_offset,
+                        (bar_offset + section_size));
+            memory_region_unref(section_mr);
+            return size;
+        }
+
+        if (vfu_object_mr_rw(section_mr, ptr, section_offset,
+                             section_size, is_write)) {
+            warn_report("vfu: failed to %s "
+                        "[0x%"PRIx64" - 0x%"PRIx64"] in bar %d",
+                        is_write ? "write to" : "read from", bar_offset,
+                        (bar_offset + section_size), pci_bar);
+            memory_region_unref(section_mr);
+            return size;
+        }
+
+        size += section_size;
+        bar_offset += section_size;
+        ptr += section_size;
+        len -= section_size;
+
+        memory_region_unref(section_mr);
+    }
+
+    return size;
+}
+
+/**
+ * VFU_OBJECT_BAR_HANDLER - macro for defining handlers for PCI BARs.
+ *
+ * To create handler for BAR number 2, VFU_OBJECT_BAR_HANDLER(2) would
+ * define vfu_object_bar2_handler
+ */
+#define VFU_OBJECT_BAR_HANDLER(BAR_NO)                                         \
+    static ssize_t vfu_object_bar##BAR_NO##_handler(vfu_ctx_t *vfu_ctx,        \
+                                        char * const buf, size_t count,        \
+                                        loff_t offset, const bool is_write)    \
+    {                                                                          \
+        VfuObject *o = vfu_get_private(vfu_ctx);                               \
+        PCIDevice *pci_dev = o->pci_dev;                                       \
+                                                                               \
+        return vfu_object_bar_rw(pci_dev, BAR_NO, offset,                      \
+                                 buf, count, is_write);                        \
+    }                                                                          \
+
+VFU_OBJECT_BAR_HANDLER(0)
+VFU_OBJECT_BAR_HANDLER(1)
+VFU_OBJECT_BAR_HANDLER(2)
+VFU_OBJECT_BAR_HANDLER(3)
+VFU_OBJECT_BAR_HANDLER(4)
+VFU_OBJECT_BAR_HANDLER(5)
+VFU_OBJECT_BAR_HANDLER(6)
+
+static vfu_region_access_cb_t *vfu_object_bar_handlers[PCI_NUM_REGIONS] = {
+    &vfu_object_bar0_handler,
+    &vfu_object_bar1_handler,
+    &vfu_object_bar2_handler,
+    &vfu_object_bar3_handler,
+    &vfu_object_bar4_handler,
+    &vfu_object_bar5_handler,
+    &vfu_object_bar6_handler,
+};
+
+/**
+ * vfu_object_register_bars - Identify active BAR regions of pdev and setup
+ *                            callbacks to handle read/write accesses
+ */
+static void vfu_object_register_bars(vfu_ctx_t *vfu_ctx, PCIDevice *pdev)
+{
+    int flags = VFU_REGION_FLAG_RW;
+    int i;
+
+    for (i = 0; i < PCI_NUM_REGIONS; i++) {
+        if (!pdev->io_regions[i].size) {
+            continue;
+        }
+
+        if ((i == VFU_PCI_DEV_ROM_REGION_IDX) ||
+            pdev->io_regions[i].memory->readonly) {
+            flags &= ~VFU_REGION_FLAG_WRITE;
+        }
+
+        vfu_setup_region(vfu_ctx, VFU_PCI_DEV_BAR0_REGION_IDX + i,
+                         (size_t)pdev->io_regions[i].size,
+                         vfu_object_bar_handlers[i],
+                         flags, NULL, 0, -1, 0);
+
+        trace_vfu_bar_register(i, pdev->io_regions[i].addr,
+                               pdev->io_regions[i].size);
+    }
+}
+
 /*
  * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
  * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
         goto fail;
     }
 
+    vfu_object_register_bars(o->vfu_ctx, o->pci_dev);
+
     ret = vfu_realize_ctx(o->vfu_ctx);
     if (ret < 0) {
         error_setg(errp, "vfu: Failed to realize device %s- %s",
diff --git a/softmmu/physmem.c b/softmmu/physmem.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/physmem.c
+++ b/softmmu/physmem.c
@@ -XXX,XX +XXX,XX @@ void memory_region_flush_rom_device(MemoryRegion *mr, hwaddr addr, hwaddr size)
     invalidate_and_set_dirty(mr, addr, size);
 }
 
-static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
+int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
 {
     unsigned access_size_max = mr->ops->valid.max_access_size;
 
@@ -XXX,XX +XXX,XX @@ static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
     return l;
 }
 
-static bool prepare_mmio_access(MemoryRegion *mr)
+bool prepare_mmio_access(MemoryRegion *mr)
 {
     bool release_lock = false;
 
diff --git a/tests/qtest/fuzz/generic_fuzz.c b/tests/qtest/fuzz/generic_fuzz.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/qtest/fuzz/generic_fuzz.c
+++ b/tests/qtest/fuzz/generic_fuzz.c
@@ -XXX,XX +XXX,XX @@ static void *pattern_alloc(pattern p, size_t len)
     return buf;
 }
 
-static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
+static int fuzz_memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
 {
     unsigned access_size_max = mr->ops->valid.max_access_size;
 
@@ -XXX,XX +XXX,XX @@ void fuzz_dma_read_cb(size_t addr, size_t len, MemoryRegion *mr)
 
         /*
          *  If mr1 isn't RAM, address_space_translate doesn't update l. Use
-         *  memory_access_size to identify the number of bytes that it is safe
-         *  to write without accidentally writing to another MemoryRegion.
+         *  fuzz_memory_access_size to identify the number of bytes that it
+         *  is safe to write without accidentally writing to another
+         *  MemoryRegion.
          */
         if (!memory_region_is_ram(mr1)) {
-            l = memory_access_size(mr1, l, addr1);
+            l = fuzz_memory_access_size(mr1, l, addr1);
         }
         if (memory_region_is_ram(mr1) ||
             memory_region_is_romd(mr1) ||
diff --git a/hw/remote/trace-events b/hw/remote/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/trace-events
+++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@ vfu_cfg_read(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u -> 0x%x"
 vfu_cfg_write(uint32_t offset, uint32_t val) "vfu: cfg: 0x%u <- 0x%x"
 vfu_dma_register(uint64_t gpa, size_t len) "vfu: registering GPA 0x%"PRIx64", %zu bytes"
 vfu_dma_unregister(uint64_t gpa) "vfu: unregistering GPA 0x%"PRIx64""
+vfu_bar_register(int i, uint64_t addr, uint64_t size) "vfu: BAR %d: addr 0x%"PRIx64" size 0x%"PRIx64""
+vfu_bar_rw_enter(const char *op, uint64_t addr) "vfu: %s request for BAR address 0x%"PRIx64""
+vfu_bar_rw_exit(const char *op, uint64_t addr) "vfu: Finished %s of BAR address 0x%"PRIx64""
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Forward remote device's interrupts to the guest

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Message-id: 9523479eaafe050677f4de2af5dd0df18c27cfd9.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS                       |   1 +
 include/hw/pci/msi.h              |   1 +
 include/hw/pci/msix.h             |   1 +
 include/hw/pci/pci.h              |  13 +++
 include/hw/remote/vfio-user-obj.h |   6 ++
 hw/pci/msi.c                      |  49 +++++++--
 hw/pci/msix.c                     |  35 ++++++-
 hw/pci/pci.c                      |  13 +++
 hw/remote/machine.c               |  16 ++-
 hw/remote/vfio-user-obj.c         | 167 ++++++++++++++++++++++++++++++
 stubs/vfio-user-obj.c             |   6 ++
 hw/remote/trace-events            |   1 +
 stubs/meson.build                 |   1 +
 13 files changed, 298 insertions(+), 12 deletions(-)
 create mode 100644 include/hw/remote/vfio-user-obj.h
 create mode 100644 stubs/vfio-user-obj.c

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: hw/remote/iohub.c
 F: include/hw/remote/iohub.h
 F: subprojects/libvfio-user
 F: hw/remote/vfio-user-obj.c
+F: include/hw/remote/vfio-user-obj.h
 F: hw/remote/iommu.c
 F: include/hw/remote/iommu.h
 
diff --git a/include/hw/pci/msi.h b/include/hw/pci/msi.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/pci/msi.h
+++ b/include/hw/pci/msi.h
@@ -XXX,XX +XXX,XX @@ void msi_notify(PCIDevice *dev, unsigned int vector);
 void msi_send_message(PCIDevice *dev, MSIMessage msg);
 void msi_write_config(PCIDevice *dev, uint32_t addr, uint32_t val, int len);
 unsigned int msi_nr_vectors_allocated(const PCIDevice *dev);
+void msi_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp);
 
 static inline bool msi_present(const PCIDevice *dev)
 {
diff --git a/include/hw/pci/msix.h b/include/hw/pci/msix.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/pci/msix.h
+++ b/include/hw/pci/msix.h
@@ -XXX,XX +XXX,XX @@ void msix_clr_pending(PCIDevice *dev, int vector);
 int msix_vector_use(PCIDevice *dev, unsigned vector);
 void msix_vector_unuse(PCIDevice *dev, unsigned vector);
 void msix_unuse_all_vectors(PCIDevice *dev);
+void msix_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp);
 
 void msix_notify(PCIDevice *dev, unsigned vector);
 
diff --git a/include/hw/pci/pci.h b/include/hw/pci/pci.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/pci/pci.h
+++ b/include/hw/pci/pci.h
@@ -XXX,XX +XXX,XX @@ extern bool pci_available;
 #define PCI_SLOT(devfn)         (((devfn) >> 3) & 0x1f)
 #define PCI_FUNC(devfn)         ((devfn) & 0x07)
 #define PCI_BUILD_BDF(bus, devfn)     ((bus << 8) | (devfn))
+#define PCI_BDF_TO_DEVFN(x)     ((x) & 0xff)
 #define PCI_BUS_MAX             256
 #define PCI_DEVFN_MAX           256
 #define PCI_SLOT_MAX            32
@@ -XXX,XX +XXX,XX @@ typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
                                 pcibus_t addr, pcibus_t size, int type);
 typedef void PCIUnregisterFunc(PCIDevice *pci_dev);
 
+typedef void MSITriggerFunc(PCIDevice *dev, MSIMessage msg);
+typedef MSIMessage MSIPrepareMessageFunc(PCIDevice *dev, unsigned vector);
+typedef MSIMessage MSIxPrepareMessageFunc(PCIDevice *dev, unsigned vector);
+
 typedef struct PCIIORegion {
     pcibus_t addr; /* current PCI mapping address. -1 means not mapped */
 #define PCI_BAR_UNMAPPED (~(pcibus_t)0)
@@ -XXX,XX +XXX,XX @@ struct PCIDevice {
     /* Space to store MSIX table & pending bit array */
     uint8_t *msix_table;
     uint8_t *msix_pba;
+
+    /* May be used by INTx or MSI during interrupt notification */
+    void *irq_opaque;
+
+    MSITriggerFunc *msi_trigger;
+    MSIPrepareMessageFunc *msi_prepare_message;
+    MSIxPrepareMessageFunc *msix_prepare_message;
+
     /* MemoryRegion container for msix exclusive BAR setup */
     MemoryRegion msix_exclusive_bar;
     /* Memory Regions for MSIX table and pending bit entries. */
diff --git a/include/hw/remote/vfio-user-obj.h b/include/hw/remote/vfio-user-obj.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/hw/remote/vfio-user-obj.h
@@ -XXX,XX +XXX,XX @@
+#ifndef VFIO_USER_OBJ_H
+#define VFIO_USER_OBJ_H
+
+void vfu_object_set_bus_irq(PCIBus *pci_bus);
+
+#endif
diff --git a/hw/pci/msi.c b/hw/pci/msi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/pci/msi.c
+++ b/hw/pci/msi.c
@@ -XXX,XX +XXX,XX @@ void msi_set_message(PCIDevice *dev, MSIMessage msg)
     pci_set_word(dev->config + msi_data_off(dev, msi64bit), msg.data);
 }
 
-MSIMessage msi_get_message(PCIDevice *dev, unsigned int vector)
+static MSIMessage msi_prepare_message(PCIDevice *dev, unsigned int vector)
 {
     uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
     bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;
@@ -XXX,XX +XXX,XX @@ MSIMessage msi_get_message(PCIDevice *dev, unsigned int vector)
     return msg;
 }
 
+MSIMessage msi_get_message(PCIDevice *dev, unsigned int vector)
+{
+    return dev->msi_prepare_message(dev, vector);
+}
+
 bool msi_enabled(const PCIDevice *dev)
 {
     return msi_present(dev) &&
@@ -XXX,XX +XXX,XX @@ int msi_init(struct PCIDevice *dev, uint8_t offset,
                      0xffffffff >> (PCI_MSI_VECTORS_MAX - nr_vectors));
     }
 
+    dev->msi_prepare_message = msi_prepare_message;
+
     return 0;
 }
 
@@ -XXX,XX +XXX,XX @@ void msi_uninit(struct PCIDevice *dev)
     cap_size = msi_cap_sizeof(flags);
     pci_del_capability(dev, PCI_CAP_ID_MSI, cap_size);
     dev->cap_present &= ~QEMU_PCI_CAP_MSI;
+    dev->msi_prepare_message = NULL;
 
     MSI_DEV_PRINTF(dev, "uninit\n");
 }
@@ -XXX,XX +XXX,XX @@ bool msi_is_masked(const PCIDevice *dev, unsigned int vector)
     return mask & (1U << vector);
 }
 
+void msi_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp)
+{
+    ERRP_GUARD();
+    uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
+    bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;
+    uint32_t irq_state, vector_mask, pending;
+
+    if (vector > PCI_MSI_VECTORS_MAX) {
+        error_setg(errp, "msi: vector %d not allocated. max vector is %d",
+                   vector, PCI_MSI_VECTORS_MAX);
+        return;
+    }
+
+    vector_mask = (1U << vector);
+
+    irq_state = pci_get_long(dev->config + msi_mask_off(dev, msi64bit));
+
+    if (mask) {
+        irq_state |= vector_mask;
+    } else {
+        irq_state &= ~vector_mask;
+    }
+
+    pci_set_long(dev->config + msi_mask_off(dev, msi64bit), irq_state);
+
+    pending = pci_get_long(dev->config + msi_pending_off(dev, msi64bit));
+    if (!mask && (pending & vector_mask)) {
+        pending &= ~vector_mask;
+        pci_set_long(dev->config + msi_pending_off(dev, msi64bit), pending);
+        msi_notify(dev, vector);
+    }
+}
+
 void msi_notify(PCIDevice *dev, unsigned int vector)
 {
     uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
@@ -XXX,XX +XXX,XX @@ void msi_notify(PCIDevice *dev, unsigned int vector)
 
 void msi_send_message(PCIDevice *dev, MSIMessage msg)
 {
-    MemTxAttrs attrs = {};
-
-    attrs.requester_id = pci_requester_id(dev);
-    address_space_stl_le(&dev->bus_master_as, msg.address, msg.data,
-                         attrs, NULL);
+    dev->msi_trigger(dev, msg);
 }
 
 /* Normally called by pci_default_write_config(). */
diff --git a/hw/pci/msix.c b/hw/pci/msix.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/pci/msix.c
+++ b/hw/pci/msix.c
@@ -XXX,XX +XXX,XX @@
 #define MSIX_ENABLE_MASK (PCI_MSIX_FLAGS_ENABLE >> 8)
 #define MSIX_MASKALL_MASK (PCI_MSIX_FLAGS_MASKALL >> 8)
 
-MSIMessage msix_get_message(PCIDevice *dev, unsigned vector)
+static MSIMessage msix_prepare_message(PCIDevice *dev, unsigned vector)
 {
     uint8_t *table_entry = dev->msix_table + vector * PCI_MSIX_ENTRY_SIZE;
     MSIMessage msg;
@@ -XXX,XX +XXX,XX @@ MSIMessage msix_get_message(PCIDevice *dev, unsigned vector)
     return msg;
 }
 
+MSIMessage msix_get_message(PCIDevice *dev, unsigned vector)
+{
+    return dev->msix_prepare_message(dev, vector);
+}
+
 /*
  * Special API for POWER to configure the vectors through
  * a side channel. Should never be used by devices.
@@ -XXX,XX +XXX,XX @@ static void msix_handle_mask_update(PCIDevice *dev, int vector, bool was_masked)
     }
 }
 
+void msix_set_mask(PCIDevice *dev, int vector, bool mask, Error **errp)
+{
+    ERRP_GUARD();
+    unsigned offset;
+    bool was_masked;
+
+    if (vector > dev->msix_entries_nr) {
+        error_setg(errp, "msix: vector %d not allocated. max vector is %d",
+                   vector, dev->msix_entries_nr);
+        return;
+    }
+
+    offset = vector * PCI_MSIX_ENTRY_SIZE + PCI_MSIX_ENTRY_VECTOR_CTRL;
+
+    was_masked = msix_is_masked(dev, vector);
+
+    if (mask) {
+        dev->msix_table[offset] |= PCI_MSIX_ENTRY_CTRL_MASKBIT;
+    } else {
+        dev->msix_table[offset] &= ~PCI_MSIX_ENTRY_CTRL_MASKBIT;
+    }
+
+    msix_handle_mask_update(dev, vector, was_masked);
+}
+
 static bool msix_masked(PCIDevice *dev)
 {
     return dev->config[dev->msix_cap + MSIX_CONTROL_OFFSET] & MSIX_MASKALL_MASK;
@@ -XXX,XX +XXX,XX @@ int msix_init(struct PCIDevice *dev, unsigned short nentries,
                           "msix-pba", pba_size);
     memory_region_add_subregion(pba_bar, pba_offset, &dev->msix_pba_mmio);
 
+    dev->msix_prepare_message = msix_prepare_message;
+
     return 0;
 }
 
@@ -XXX,XX +XXX,XX @@ void msix_uninit(PCIDevice *dev, MemoryRegion *table_bar, MemoryRegion *pba_bar)
     g_free(dev->msix_entry_used);
     dev->msix_entry_used = NULL;
     dev->cap_present &= ~QEMU_PCI_CAP_MSIX;
+    dev->msix_prepare_message = NULL;
 }
 
 void msix_uninit_exclusive_bar(PCIDevice *dev)
diff --git a/hw/pci/pci.c b/hw/pci/pci.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/pci/pci.c
+++ b/hw/pci/pci.c
@@ -XXX,XX +XXX,XX @@ void pci_device_deassert_intx(PCIDevice *dev)
     }
 }
 
+static void pci_msi_trigger(PCIDevice *dev, MSIMessage msg)
+{
+    MemTxAttrs attrs = {};
+
+    attrs.requester_id = pci_requester_id(dev);
+    address_space_stl_le(&dev->bus_master_as, msg.address, msg.data,
+                         attrs, NULL);
+}
+
 static void pci_reset_regions(PCIDevice *dev)
 {
     int r;
@@ -XXX,XX +XXX,XX @@ static void pci_qdev_unrealize(DeviceState *dev)
 
     pci_device_deassert_intx(pci_dev);
     do_pci_unregister_device(pci_dev);
+
+    pci_dev->msi_trigger = NULL;
 }
 
 void pci_register_bar(PCIDevice *pci_dev, int region_num,
@@ -XXX,XX +XXX,XX @@ static void pci_qdev_realize(DeviceState *qdev, Error **errp)
     }
 
     pci_set_power(pci_dev, true);
+
+    pci_dev->msi_trigger = pci_msi_trigger;
 }
 
 PCIDevice *pci_new_multifunction(int devfn, bool multifunction,
diff --git a/hw/remote/machine.c b/hw/remote/machine.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/machine.c
+++ b/hw/remote/machine.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/remote/iommu.h"
 #include "hw/qdev-core.h"
 #include "hw/remote/iommu.h"
+#include "hw/remote/vfio-user-obj.h"
+#include "hw/pci/msi.h"
 
 static void remote_machine_init(MachineState *machine)
 {
@@ -XXX,XX +XXX,XX @@ static void remote_machine_init(MachineState *machine)
 
     if (s->vfio_user) {
         remote_iommu_setup(pci_host->bus);
+
+        msi_nonbroken = true;
+
+        vfu_object_set_bus_irq(pci_host->bus);
+    } else {
+        remote_iohub_init(&s->iohub);
+
+        pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, remote_iohub_map_irq,
+                     &s->iohub, REMOTE_IOHUB_NB_PIRQS);
     }
 
-    remote_iohub_init(&s->iohub);
-
-    pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, remote_iohub_map_irq,
-                 &s->iohub, REMOTE_IOHUB_NB_PIRQS);
-
     qbus_set_hotplug_handler(BUS(pci_host->bus), OBJECT(s));
 }
 
diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/pci/pci.h"
 #include "qemu/timer.h"
 #include "exec/memory.h"
+#include "hw/pci/msi.h"
+#include "hw/pci/msix.h"
+#include "hw/remote/vfio-user-obj.h"
 
 #define TYPE_VFU_OBJECT "x-vfio-user-server"
 OBJECT_DECLARE_TYPE(VfuObject, VfuObjectClass, VFU_OBJECT)
@@ -XXX,XX +XXX,XX @@ struct VfuObject {
     Error *unplug_blocker;
 
     int vfu_poll_fd;
+
+    MSITriggerFunc *default_msi_trigger;
+    MSIPrepareMessageFunc *default_msi_prepare_message;
+    MSIxPrepareMessageFunc *default_msix_prepare_message;
 };
 
 static void vfu_object_init_ctx(VfuObject *o, Error **errp);
@@ -XXX,XX +XXX,XX @@ static void vfu_object_register_bars(vfu_ctx_t *vfu_ctx, PCIDevice *pdev)
     }
 }
 
+static int vfu_object_map_irq(PCIDevice *pci_dev, int intx)
+{
+    int pci_bdf = PCI_BUILD_BDF(pci_bus_num(pci_get_bus(pci_dev)),
+                                pci_dev->devfn);
+
+    return pci_bdf;
+}
+
+static void vfu_object_set_irq(void *opaque, int pirq, int level)
+{
+    PCIBus *pci_bus = opaque;
+    PCIDevice *pci_dev = NULL;
+    vfu_ctx_t *vfu_ctx = NULL;
+    int pci_bus_num, devfn;
+
+    if (level) {
+        pci_bus_num = PCI_BUS_NUM(pirq);
+        devfn = PCI_BDF_TO_DEVFN(pirq);
+
+        /*
+         * pci_find_device() performs at O(1) if the device is attached
+         * to the root PCI bus. Whereas, if the device is attached to a
+         * secondary PCI bus (such as when a root port is involved),
+         * finding the parent PCI bus could take O(n)
+         */
+        pci_dev = pci_find_device(pci_bus, pci_bus_num, devfn);
+
+        vfu_ctx = pci_dev->irq_opaque;
+
+        g_assert(vfu_ctx);
+
+        vfu_irq_trigger(vfu_ctx, 0);
+    }
+}
+
+static MSIMessage vfu_object_msi_prepare_msg(PCIDevice *pci_dev,
+                                             unsigned int vector)
+{
+    MSIMessage msg;
+
+    msg.address = 0;
+    msg.data = vector;
+
+    return msg;
+}
+
+static void vfu_object_msi_trigger(PCIDevice *pci_dev, MSIMessage msg)
+{
+    vfu_ctx_t *vfu_ctx = pci_dev->irq_opaque;
+
+    vfu_irq_trigger(vfu_ctx, msg.data);
+}
+
+static void vfu_object_setup_msi_cbs(VfuObject *o)
+{
+    o->default_msi_trigger = o->pci_dev->msi_trigger;
+    o->default_msi_prepare_message = o->pci_dev->msi_prepare_message;
+    o->default_msix_prepare_message = o->pci_dev->msix_prepare_message;
+
+    o->pci_dev->msi_trigger = vfu_object_msi_trigger;
+    o->pci_dev->msi_prepare_message = vfu_object_msi_prepare_msg;
+    o->pci_dev->msix_prepare_message = vfu_object_msi_prepare_msg;
+}
+
+static void vfu_object_restore_msi_cbs(VfuObject *o)
+{
+    o->pci_dev->msi_trigger = o->default_msi_trigger;
+    o->pci_dev->msi_prepare_message = o->default_msi_prepare_message;
+    o->pci_dev->msix_prepare_message = o->default_msix_prepare_message;
+}
+
+static void vfu_msix_irq_state(vfu_ctx_t *vfu_ctx, uint32_t start,
+                               uint32_t count, bool mask)
+{
+    VfuObject *o = vfu_get_private(vfu_ctx);
+    Error *err = NULL;
+    uint32_t vector;
+
+    for (vector = start; vector < count; vector++) {
+        msix_set_mask(o->pci_dev, vector, mask, &err);
+        if (err) {
+            VFU_OBJECT_ERROR(o, "vfu: %s: %s", o->device,
+                             error_get_pretty(err));
+            error_free(err);
+            err = NULL;
+        }
+    }
+}
+
+static void vfu_msi_irq_state(vfu_ctx_t *vfu_ctx, uint32_t start,
+                              uint32_t count, bool mask)
+{
+    VfuObject *o = vfu_get_private(vfu_ctx);
+    Error *err = NULL;
+    uint32_t vector;
+
+    for (vector = start; vector < count; vector++) {
+        msi_set_mask(o->pci_dev, vector, mask, &err);
+        if (err) {
+            VFU_OBJECT_ERROR(o, "vfu: %s: %s", o->device,
+                             error_get_pretty(err));
+            error_free(err);
+            err = NULL;
+        }
+    }
+}
+
+static int vfu_object_setup_irqs(VfuObject *o, PCIDevice *pci_dev)
+{
+    vfu_ctx_t *vfu_ctx = o->vfu_ctx;
+    int ret;
+
+    ret = vfu_setup_device_nr_irqs(vfu_ctx, VFU_DEV_INTX_IRQ, 1);
+    if (ret < 0) {
+        return ret;
+    }
+
+    if (msix_nr_vectors_allocated(pci_dev)) {
+        ret = vfu_setup_device_nr_irqs(vfu_ctx, VFU_DEV_MSIX_IRQ,
+                                       msix_nr_vectors_allocated(pci_dev));
+        vfu_setup_irq_state_callback(vfu_ctx, VFU_DEV_MSIX_IRQ,
+                                     &vfu_msix_irq_state);
+    } else if (msi_nr_vectors_allocated(pci_dev)) {
+        ret = vfu_setup_device_nr_irqs(vfu_ctx, VFU_DEV_MSI_IRQ,
+                                       msi_nr_vectors_allocated(pci_dev));
+        vfu_setup_irq_state_callback(vfu_ctx, VFU_DEV_MSI_IRQ,
+                                     &vfu_msi_irq_state);
+    }
+
+    if (ret < 0) {
+        return ret;
+    }
+
+    vfu_object_setup_msi_cbs(o);
+
+    pci_dev->irq_opaque = vfu_ctx;
+
+    return 0;
+}
+
+void vfu_object_set_bus_irq(PCIBus *pci_bus)
+{
+    int bus_num = pci_bus_num(pci_bus);
+    int max_bdf = PCI_BUILD_BDF(bus_num, PCI_DEVFN_MAX - 1);
+
+    pci_bus_irqs(pci_bus, vfu_object_set_irq, vfu_object_map_irq, pci_bus,
+                 max_bdf);
+}
+
 /*
  * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
  * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
 
     vfu_object_register_bars(o->vfu_ctx, o->pci_dev);
 
+    ret = vfu_object_setup_irqs(o, o->pci_dev);
+    if (ret < 0) {
+        error_setg(errp, "vfu: Failed to setup interrupts for %s",
+                   o->device);
+        goto fail;
+    }
+
     ret = vfu_realize_ctx(o->vfu_ctx);
     if (ret < 0) {
         error_setg(errp, "vfu: Failed to realize device %s- %s",
@@ -XXX,XX +XXX,XX @@ fail:
         o->unplug_blocker = NULL;
     }
     if (o->pci_dev) {
+        vfu_object_restore_msi_cbs(o);
+        o->pci_dev->irq_opaque = NULL;
         object_unref(OBJECT(o->pci_dev));
         o->pci_dev = NULL;
     }
@@ -XXX,XX +XXX,XX @@ static void vfu_object_finalize(Object *obj)
     }
 
     if (o->pci_dev) {
+        vfu_object_restore_msi_cbs(o);
+        o->pci_dev->irq_opaque = NULL;
         object_unref(OBJECT(o->pci_dev));
         o->pci_dev = NULL;
     }
diff --git a/stubs/vfio-user-obj.c b/stubs/vfio-user-obj.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/stubs/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@
+#include "qemu/osdep.h"
+#include "hw/remote/vfio-user-obj.h"
+
+void vfu_object_set_bus_irq(PCIBus *pci_bus)
+{
+}
diff --git a/hw/remote/trace-events b/hw/remote/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/trace-events
+++ b/hw/remote/trace-events
@@ -XXX,XX +XXX,XX @@ vfu_dma_unregister(uint64_t gpa) "vfu: unregistering GPA 0x%"PRIx64""
 vfu_bar_register(int i, uint64_t addr, uint64_t size) "vfu: BAR %d: addr 0x%"PRIx64" size 0x%"PRIx64""
 vfu_bar_rw_enter(const char *op, uint64_t addr) "vfu: %s request for BAR address 0x%"PRIx64""
 vfu_bar_rw_exit(const char *op, uint64_t addr) "vfu: Finished %s of BAR address 0x%"PRIx64""
+vfu_interrupt(int pirq) "vfu: sending interrupt to device - PIRQ %d"
diff --git a/stubs/meson.build b/stubs/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/stubs/meson.build
+++ b/stubs/meson.build
@@ -XXX,XX +XXX,XX @@ if have_system
 else
   stub_ss.add(files('qdev.c'))
 endif
+stub_ss.add(when: 'CONFIG_VFIO_USER_SERVER', if_false: files('vfio-user-obj.c'))
-- 
2.36.1

From: Jagannathan Raman <jag.raman@oracle.com>

Adds handler to reset a remote device

Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 112eeadf3bc4c6cdb100bc3f9a6fcfc20b467c1b.1655151679.git.jag.raman@oracle.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/remote/vfio-user-obj.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/vfio-user-obj.c
+++ b/hw/remote/vfio-user-obj.c
@@ -XXX,XX +XXX,XX @@ void vfu_object_set_bus_irq(PCIBus *pci_bus)
                  max_bdf);
 }
 
+static int vfu_object_device_reset(vfu_ctx_t *vfu_ctx, vfu_reset_type_t type)
+{
+    VfuObject *o = vfu_get_private(vfu_ctx);
+
+    /* vfu_object_ctx_run() handles lost connection */
+    if (type == VFU_RESET_LOST_CONN) {
+        return 0;
+    }
+
+    qdev_reset_all(DEVICE(o->pci_dev));
+
+    return 0;
+}
+
 /*
  * TYPE_VFU_OBJECT depends on the availability of the 'socket' and 'device'
  * properties. It also depends on devices instantiated in QEMU. These
@@ -XXX,XX +XXX,XX @@ static void vfu_object_init_ctx(VfuObject *o, Error **errp)
         goto fail;
     }
 
+    ret = vfu_setup_device_reset_cb(o->vfu_ctx, &vfu_object_device_reset);
+    if (ret < 0) {
+        error_setg(errp, "vfu: Failed to setup reset callback");
+        goto fail;
+    }
+
     ret = vfu_realize_ctx(o->vfu_ctx);
     if (ret < 0) {
         error_setg(errp, "vfu: Failed to realize device %s- %s",
-- 
2.36.1

Every laio_io_plug() call has a matching laio_io_unplug() call. There is
a plugged counter that tracks the number of levels of plugging and
allows for nesting.

The plugged counter must reflect the balance between laio_io_plug() and
laio_io_unplug() calls accurately. Otherwise I/O stalls occur since
io_submit(2) calls are skipped while plugged.

Reported-by: Nikolay Tenev <nt@storpool.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20220609164712.1539045-2-stefanha@redhat.com
Cc: Stefano Garzarella <sgarzare@redhat.com>
Fixes: 68d7946648 ("linux-aio: add `dev_max_batch` parameter to laio_io_unplug()")
[Stefano Garzarella suggested adding a Fixes tag.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/linux-aio.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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 @@ void laio_io_unplug(BlockDriverState *bs, LinuxAioState *s,
                     uint64_t dev_max_batch)
 {
     assert(s->io_q.plugged);
+    s->io_q.plugged--;
+
     if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch) ||
-        (--s->io_q.plugged == 0 &&
+        (!s->io_q.plugged &&
          !s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending))) {
         ioq_submit(s);
     }
-- 
2.36.1

It may not be obvious why laio_io_unplug() checks max batch. I discussed
this with Stefano and have added a comment summarizing the reason.

Cc: Stefano Garzarella <sgarzare@redhat.com>
Cc: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20220609164712.1539045-3-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/linux-aio.c | 6 ++++++
 1 file changed, 6 insertions(+)

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 @@ void laio_io_unplug(BlockDriverState *bs, LinuxAioState *s,
     assert(s->io_q.plugged);
     s->io_q.plugged--;
 
+    /*
+     * Why max batch checking is performed here:
+     * Another BDS may have queued requests with a higher dev_max_batch and
+     * therefore in_queue could now exceed our dev_max_batch. Re-check the max
+     * batch so we can honor our device's dev_max_batch.
+     */
     if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch) ||
         (!s->io_q.plugged &&
          !s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending))) {
-- 
2.36.1