Series comparison

-[Qemu-devel] [PULL for-2.10 00/15] Block patches
+[Qemu-devel] [PULL v2 00/16] Block patches
-The following changes since commit 248b23735645f7cbb503d9be6f5bf825f2a603ab:
+The following changes since commit 54b89db5309d5fa8b5d3fe5fe56f81704e2f9706:
-  Update version for v2.10.0-rc4 release (2017-08-24 17:34:26 +0100)
+  Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging (2019-09-03 09:43:26 +0100)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://github.com/XanClic/qemu.git tags/pull-block-2019-09-03
-for you to fetch changes up to 3e4c705212abfe8c9882a00beb2d1466a8a53cec:
+for you to fetch changes up to 755c5fe79d88717600356d3edf04835bba43dcb6:
-  qcow2: allocate cluster_cache/cluster_data on demand (2017-08-30 18:02:10 +0100)
+  iotests: Unify cache mode quoting (2019-09-03 14:56:06 +0200)
 ----------------------------------------------------------------
+Block patches:
+- qemu-io now accepts a file to read a write pattern from
+- Ensure that raw files have their first block allocated so we can probe
+  the O_DIRECT alignment if necessary
+- Various fixes
 ----------------------------------------------------------------
+v2:
+- Added a patch we already had on the list to keep the iotests passing
+  when $DISPLAY is not set
-Alberto Garcia (8):
+----------------------------------------------------------------
-  throttle: Fix wrong variable name in the header documentation
+Denis Plotnikov (1):
-  throttle: Update the throttle_fix_bucket() documentation
+  qemu-io: add pattern file for write command
   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):
+Max Reitz (8):
-  nvme: Fix get/set number of queues feature, again
+  iotests: Fix _filter_img_create()
   vmdk: Use bdrv_dirname() for relative extent paths
   iotests: Keep testing broken relative extent paths
   vmdk: Reject invalid compressed writes
   iotests: Disable broken streamOptimized tests
   iotests: Disable 110 for vmdk.twoGbMaxExtentSparse
   iotests: Disable 126 for flat vmdk subformats
   iotests: Add -display none to the qemu options
-Eduardo Habkost (1):
+Nir Soffer (3):
-  oslib-posix: Print errors before aborting on qemu_alloc_stack()
+  block: posix: Always allocate the first block
   iotests: Test allocate_first_block() with O_DIRECT
   iotests: Unify cache mode quoting
-Fred Rolland (1):
+Stefan Hajnoczi (1):
-  qemu-doc: Add UUID support in initiator name
+  file-posix: fix request_alignment typo
-Stefan Hajnoczi (4):
+Thomas Huth (2):
-  scripts: add argparse module for Python 2.6 compatibility
+  iotests: Check for enabled drivers before testing them
-  docker.py: Python 2.6 argparse compatibility
+  tests/check-block: Skip iotests when sanitizers are enabled
   tests: migration/guestperf Python 2.6 argparse compatibility
   qcow2: allocate cluster_cache/cluster_data on demand
- include/qemu/throttle.h            |    8 +-
+Vladimir Sementsov-Ogievskiy (1):
- block/qcow.c                       |   12 +-
+  block: fix permission update in bdrv_replace_node
- block/qcow2-cluster.c              |   17 +
- block/qcow2.c                      |   20 +-
+ block.c                                       |  5 +-
- dump.c                             |    4 +-
+ block/file-posix.c                            | 53 +++++++++-
- hw/block/nvme.c                    |    4 +-
+ block/vmdk.c                                  | 64 ++++++++----
- tests/test-throttle.c              |   80 +-
+ qemu-io-cmds.c                                | 99 +++++++++++++++++--
- util/oslib-posix.c                 |    2 +
+ tests/check-block.sh                          |  5 +
- util/throttle.c                    |   86 +-
+ tests/qemu-iotests/002                        |  1 +
- COPYING.PYTHON                     |  270 ++++
+ tests/qemu-iotests/003                        |  1 +
- qemu-doc.texi                      |    5 +-
+ tests/qemu-iotests/005                        |  3 +-
- scripts/argparse.py                | 2406 ++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/009                        |  1 +
- tests/docker/docker.py             |    4 +-
+ tests/qemu-iotests/010                        |  1 +
- tests/migration/guestperf/shell.py |    8 +-
+ tests/qemu-iotests/011                        |  1 +
-files changed, 2831 insertions(+), 95 deletions(-)
+ tests/qemu-iotests/017                        |  3 +-
- create mode 100644 COPYING.PYTHON
+ tests/qemu-iotests/018                        |  3 +-
- create mode 100644 scripts/argparse.py
+ tests/qemu-iotests/019                        |  3 +-
  tests/qemu-iotests/020                        |  3 +-
  tests/qemu-iotests/026                        |  4 +-
  tests/qemu-iotests/027                        |  1 +
  tests/qemu-iotests/032                        |  1 +
  tests/qemu-iotests/033                        |  1 +
  tests/qemu-iotests/034                        |  3 +-
  tests/qemu-iotests/037                        |  3 +-
  tests/qemu-iotests/039                        |  4 +-
  tests/qemu-iotests/052                        |  2 +-
  tests/qemu-iotests/059                        | 34 ++++++-
  tests/qemu-iotests/059.out                    | 26 +++--
  tests/qemu-iotests/063                        |  3 +-
  tests/qemu-iotests/071                        |  1 +
  tests/qemu-iotests/072                        |  1 +
  tests/qemu-iotests/081                        |  4 +-
  tests/qemu-iotests/091                        |  4 +-
  tests/qemu-iotests/099                        |  1 +
  tests/qemu-iotests/105                        |  3 +-
  tests/qemu-iotests/110                        |  3 +-
  tests/qemu-iotests/120                        |  1 +
  tests/qemu-iotests/126                        |  2 +
  tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
  tests/qemu-iotests/150.out.raw                | 12 +++
  tests/qemu-iotests/162                        |  4 +-
  tests/qemu-iotests/175                        | 47 +++++++--
  tests/qemu-iotests/175.out                    | 16 ++-
  tests/qemu-iotests/178.out.qcow2              |  4 +-
  tests/qemu-iotests/184                        |  1 +
  tests/qemu-iotests/186                        |  1 +
  tests/qemu-iotests/197                        |  1 +
  tests/qemu-iotests/215                        |  1 +
  tests/qemu-iotests/221.out                    | 12 ++-
  tests/qemu-iotests/251                        |  1 +
  tests/qemu-iotests/253.out                    | 12 ++-
  tests/qemu-iotests/check                      |  6 +-
  tests/qemu-iotests/common.filter              |  4 +-
  tests/qemu-iotests/common.rc                  | 14 +++
 files changed, 394 insertions(+), 90 deletions(-)
  rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
  create mode 100644 tests/qemu-iotests/150.out.raw
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 05/15] throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
+[Qemu-devel] [PULL v2 01/16] qemu-io: add pattern file for write command
-From: Alberto Garcia <berto@igalia.com>
+From: Denis Plotnikov <dplotnikov@virtuozzo.com>
-The throttling code can change internally the value of bkt->max if it
+The patch allows to provide a pattern file for write
-hasn't been set by the user. The problem with this is that if we want
+command. There was no similar ability before.
 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: Denis Plotnikov <dplotnikov@virtuozzo.com>
-Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
+Message-id: 20190820164616.4072-1-dplotnikov@virtuozzo.com
-Message-id: 5b0b9e1ac6eb208d709eddc7b09e7669a523bff3.1503580370.git.berto@igalia.com
+Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+[mreitz: Keep optstring in alphabetical order]
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- util/throttle.c | 62 +++++++++++++++++++++------------------------------------
+ qemu-io-cmds.c | 99 +++++++++++++++++++++++++++++++++++++++++++++++---
-file changed, 23 insertions(+), 39 deletions(-)
+file changed, 93 insertions(+), 6 deletions(-)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/qemu-io-cmds.c
-+++ b/util/throttle.c
++++ b/qemu-io-cmds.c
-@@ -XXX,XX +XXX,XX @@ static int64_t throttle_do_compute_wait(double limit, double extra)
+@@ -XXX,XX +XXX,XX @@ static void qemu_io_free(void *p)
- int64_t throttle_compute_wait(LeakyBucket *bkt)
+     qemu_vfree(p);
- {
+ }
-     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 */
++ * qemu_io_alloc_from_file()
++ *
-     if (!bkt->avg) {
++ * Allocates the buffer and populates it with the content of the given file
-         return 0;
++ * up to @len bytes. If the file length is less than @len, then the buffer
-     }
++ * is populated with the file content cyclically.
++ *
--    /* If the bucket is full then we have to wait */
++ * @blk - the block backend where the buffer content is going to be written to
--    extra = bkt->level - bkt->max * bkt->burst_length;
++ * @len - the buffer length
-+    if (!bkt->max) {
++ * @file_name - the file to read the content from
-+        /* 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
++ * Returns: the buffer pointer on success
-+         * and performance will suffer considerably. */
++ *          NULL on error
-+        bucket_size = bkt->avg / 10;
++ */
-+        burst_bucket_size = 0;
++static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len,
-+    } else {
++                                     const char *file_name)
-+        /* 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 */
++    char *buf, *buf_origin;
-+        bucket_size = bkt->max * bkt->burst_length;
++    FILE *f = fopen(file_name, "r");
-+        burst_bucket_size = bkt->max / 10;
++    int pattern_len;
 +
 +    if (!f) {
 +        perror(file_name);
 +        return NULL;
 +    }
 +
-+    /* If the main bucket is full then we have to wait */
++    if (qemuio_misalign) {
-+    extra = bkt->level - bucket_size;
++        len += MISALIGN_OFFSET;
-     if (extra > 0) {
++    }
-         return throttle_do_compute_wait(bkt->avg, extra);
++
 +    buf_origin = buf = blk_blockalign(blk, len);
 +
 +    if (qemuio_misalign) {
 +        buf_origin += MISALIGN_OFFSET;
 +        buf += MISALIGN_OFFSET;
 +        len -= MISALIGN_OFFSET;
 +    }
 +
 +    pattern_len = fread(buf_origin, 1, len, f);
 +
 +    if (ferror(f)) {
 +        perror(file_name);
 +        goto error;
 +    }
 +
 +    if (pattern_len == 0) {
 +        fprintf(stderr, "%s: file is empty\n", file_name);
 +        goto error;
 +    }
 +
 +    fclose(f);
 +
 +    if (len > pattern_len) {
 +        len -= pattern_len;
 +        buf += pattern_len;
 +
 +        while (len > 0) {
 +            size_t len_to_copy = MIN(pattern_len, len);
 +
 +            memcpy(buf, buf_origin, len_to_copy);
 +
 +            len -= len_to_copy;
 +            buf += len_to_copy;
 +        }
 +    }
 +
 +    return buf_origin;
 +
 +error:
 +    qemu_io_free(buf_origin);
 +    return NULL;
 +}
 +
  static void dump_buffer(const void *buffer, int64_t offset, int64_t len)
  {
      uint64_t i;
@@ -XXX,XX +XXX,XX @@ static void write_help(void)
  " -n, -- with -z, don't allow slow fallback\n"
  " -p, -- ignored for backwards compatibility\n"
  " -P, -- use different pattern to fill file\n"
 +" -s, -- use a pattern file to fill the write buffer\n"
  " -C, -- report statistics in a machine parsable format\n"
  " -q, -- quiet mode, do not show I/O statistics\n"
  " -u, -- with -z, allow unmapping\n"
@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t write_cmd = {
      .perm       = BLK_PERM_WRITE,
      .argmin     = 2,
      .argmax     = -1,
 -    .args       = "[-bcCfnquz] [-P pattern] off len",
 +    .args       = "[-bcCfnquz] [-P pattern | -s source_file] off len",
      .oneline    = "writes a number of bytes at a specified offset",
      .help       = write_help,
  };
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
  {
      struct timespec t1, t2;
      bool Cflag = false, qflag = false, bflag = false;
 -    bool Pflag = false, zflag = false, cflag = false;
 +    bool Pflag = false, zflag = false, cflag = false, sflag = false;
      int flags = 0;
      int c, cnt, ret;
      char *buf = NULL;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
      /* Some compilers get confused and warn if this is not initialized.  */
      int64_t total = 0;
      int pattern = 0xcd;
 +    const char *file_name = NULL;
 -    while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {
 +    while ((c = getopt(argc, argv, "bcCfnpP:qs:uz")) != -1) {
          switch (c) {
          case 'b':
              bflag = true;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
          case 'q':
              qflag = true;
              break;
 +        case 's':
 +            sflag = true;
 +            file_name = optarg;
 +            break;
          case 'u':
              flags |= BDRV_REQ_MAY_UNMAP;
              break;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
          return -EINVAL;
      }
--    /* If the bucket is not full yet we have to make sure that we
+-    if (zflag && Pflag) {
--     * fulfill the goal of bkt->max units per second. */
+-        printf("-z and -P cannot be specified at the same time\n");
-+    /* If the main bucket is not full yet we still have to check the
++    if (zflag + Pflag + sflag > 1) {
-+     * burst bucket in order to enforce the burst limit */
++        printf("Only one of -z, -P, and -s "
-     if (bkt->burst_length > 1) {
++               "can be specified at the same time\n");
--        /* We use 1/10 of the max value to smooth the throttling.
+         return -EINVAL;
 -         * 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 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
-@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
+     }
-  */
- void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
+     if (!zflag) {
- {
+-        buf = qemu_io_alloc(blk, count, pattern);
--    int i;
++        if (sflag) {
--
++            buf = qemu_io_alloc_from_file(blk, count, file_name);
-     *cfg = ts->cfg;
++            if (!buf) {
--
++                return -EINVAL;
--    for (i = 0; i < BUCKETS_COUNT; i++) {
++            }
--        throttle_unfix_bucket(&cfg->buckets[i]);
++        } else {
--    }
++            buf = qemu_io_alloc(blk, count, pattern);
- }
++        }
+     }
      clock_gettime(CLOCK_MONOTONIC, &t1);
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 15/15] qcow2: allocate cluster_cache/cluster_data on demand
+[Qemu-devel] [PULL v2 02/16] block: fix permission update in bdrv_replace_node
-Most qcow2 files are uncompressed so it is wasteful to allocate (32 + 1)
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.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
+It's wrong to OR shared permissions. It may lead to crash on further
-code paths that can allocate these buffers, so remove the free functions
+permission updates.
-in the error code path.
+Also, no needs to consider previously calculated permissions, as at
 this point we already bind all new parents and bdrv_get_cumulative_perm
 result is enough. So fix the bug by just set permissions by
 bdrv_get_cumulative_perm result.
-This patch can result in significant memory savings when many qcow2
+Bug was introduced in long ago 234ac1a9025, in 2.9.
 disks are attached or backing file chains are long:
-Before 12.81% (1,023,193,088B)
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-After   5.36% (393,893,888B)
+Message-id: 20190824100740.61635-1-vsementsov@virtuozzo.com
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block.c | 5 ++---
 file changed, 2 insertions(+), 3 deletions(-)
-Reported-by: Alexey Kardashevskiy <aik@ozlabs.ru>
+diff --git a/block.c b/block.c
 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 ------------
 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
+--- a/block.c
-+++ b/block/qcow2-cluster.c
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
+@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
-         nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
+ {
-         sector_offset = coffset & 511;
+     BdrvChild *c, *next;
-         csize = nb_csectors * 512 - sector_offset;
+     GSList *list = NULL, *p;
-+
+-    uint64_t old_perm, old_shared;
-+        /* Allocate buffers on first decompress operation, most images are
+     uint64_t perm = 0, shared = BLK_PERM_ALL;
-+         * uncompressed and the memory overhead can be avoided.  The buffers
+     int ret;
-+         * are freed in .bdrv_close().
-+         */
+@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
-+        if (!s->cluster_data) {
+         bdrv_unref(from);
 +            /* 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);
+-    bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
--    /* one more sector for decompressed data alignment */
+-    bdrv_set_perm(to, old_perm | perm, old_shared | shared);
--    s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
++    bdrv_get_cumulative_perm(to, &perm, &shared);
--                                                    * s->cluster_size + 512);
++    bdrv_set_perm(to, perm, shared);
--    if (s->cluster_data == NULL) {
--        error_setg(errp, "Could not allocate temporary cluster buffer");
+ out:
--        ret = -ENOMEM;
+     g_slist_free(list);
 -        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;
 --
-.13.5
+.21.0

-New patch
+[Qemu-devel] [PULL v2 03/16] block: posix: Always allocate the first block
+From: Nir Soffer <nirsof@gmail.com>
 When creating an image with preallocation "off" or "falloc", the first
 block of the image is typically not allocated. When using Gluster
 storage backed by XFS filesystem, reading this block using direct I/O
 succeeds regardless of request length, fooling alignment detection.
 In this case we fallback to a safe value (4096) instead of the optimal
 value (512), which may lead to unneeded data copying when aligning
 requests.  Allocating the first block avoids the fallback.
 Since we allocate the first block even with preallocation=off, we no
 longer create images with zero disk size:
     $ ./qemu-img create -f raw test.raw 1g
     Formatting 'test.raw', fmt=raw size=1073741824
     $ ls -lhs test.raw
 .0K -rw-r--r--. 1 nsoffer nsoffer 1.0G Aug 16 23:48 test.raw
 And converting the image requires additional cluster:
     $ ./qemu-img measure -f raw -O qcow2 test.raw
     required size: 458752
     fully allocated size: 1074135040
 When using format like vmdk with multiple files per image, we allocate
 one block per file:
     $ ./qemu-img create -f vmdk -o subformat=twoGbMaxExtentFlat test.vmdk 4g
     Formatting 'test.vmdk', fmt=vmdk size=4294967296 compat6=off hwversion=undefined subformat=twoGbMaxExtentFlat
     $ ls -lhs test*.vmdk
 .0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f001.vmdk
 .0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f002.vmdk
 .0K -rw-r--r--. 1 nsoffer nsoffer  353 Aug 27 03:23 test.vmdk
 I did quick performance test for copying disks with qemu-img convert to
 new raw target image to Gluster storage with sector size of 512 bytes:
     for i in $(seq 10); do
         rm -f dst.raw
         sleep 10
         time ./qemu-img convert -f raw -O raw -t none -T none src.raw dst.raw
     done
 Here is a table comparing the total time spent:
 Type    Before(s)   After(s)    Diff(%)
 ---------------------------------------
 real      530.028    469.123      -11.4
 user       17.204     10.768      -37.4
 sys        17.881      7.011      -60.7
 We can see very clear improvement in CPU usage.
 Signed-off-by: Nir Soffer <nsoffer@redhat.com>
 Message-id: 20190827010528.8818-2-nsoffer@redhat.com
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/file-posix.c                            | 51 +++++++++++++++++++
  tests/qemu-iotests/059.out                    |  2 +-
  tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
  tests/qemu-iotests/150.out.raw                | 12 +++++
  tests/qemu-iotests/175                        | 19 ++++---
  tests/qemu-iotests/175.out                    |  8 +--
  tests/qemu-iotests/178.out.qcow2              |  4 +-
  tests/qemu-iotests/221.out                    | 12 +++--
  tests/qemu-iotests/253.out                    | 12 +++--
 files changed, 99 insertions(+), 21 deletions(-)
  rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
  create mode 100644 tests/qemu-iotests/150.out.raw
 diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-posix.c
 +++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
      return ret;
  }
 +/*
 + * Help alignment probing by allocating the first block.
 + *
 + * When reading with direct I/O from unallocated area on Gluster backed by XFS,
 + * reading succeeds regardless of request length. In this case we fallback to
 + * safe alignment which is not optimal. Allocating the first block avoids this
 + * fallback.
 + *
 + * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
 + * request alignment, so we use safe values.
 + *
 + * Returns: 0 on success, -errno on failure. Since this is an optimization,
 + * caller may ignore failures.
 + */
 +static int allocate_first_block(int fd, size_t max_size)
 +{
 +    size_t write_size = (max_size < MAX_BLOCKSIZE)
 +        ? BDRV_SECTOR_SIZE
 +        : MAX_BLOCKSIZE;
 +    size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
 +    void *buf;
 +    ssize_t n;
 +    int ret;
 +
 +    buf = qemu_memalign(max_align, write_size);
 +    memset(buf, 0, write_size);
 +
 +    do {
 +        n = pwrite(fd, buf, write_size, 0);
 +    } while (n == -1 && errno == EINTR);
 +
 +    ret = (n == -1) ? -errno : 0;
 +
 +    qemu_vfree(buf);
 +    return ret;
 +}
 +
  static int handle_aiocb_truncate(void *opaque)
  {
      RawPosixAIOData *aiocb = opaque;
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
                  /* posix_fallocate() doesn't set errno. */
                  error_setg_errno(errp, -result,
                                   "Could not preallocate new data");
 +            } else if (current_length == 0) {
 +                /*
 +                 * posix_fallocate() uses fallocate() if the filesystem
 +                 * supports it, or fallback to manually writing zeroes. If
 +                 * fallocate() was used, unaligned reads from the fallocated
 +                 * area in raw_probe_alignment() will succeed, hence we need to
 +                 * allocate the first block.
 +                 *
 +                 * Optimize future alignment probing; ignore failures.
 +                 */
 +                allocate_first_block(fd, offset);
              }
          } else {
              result = 0;
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
          if (ftruncate(fd, offset) != 0) {
              result = -errno;
              error_setg_errno(errp, -result, "Could not resize file");
 +        } else if (current_length == 0 && offset > current_length) {
 +            /* Optimize future alignment probing; ignore failures. */
 +            allocate_first_block(fd, offset);
          }
          return result;
      default:
 diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/059.out
 +++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMax
  image: TEST_DIR/t.vmdk
  file format: vmdk
  virtual size: 0.977 TiB (1073741824000 bytes)
 -disk size: 16 KiB
 +disk size: 1.97 MiB
  Format specific information:
      cid: XXXXXXXX
      parent cid: XXXXXXXX
 diff --git a/tests/qemu-iotests/150.out b/tests/qemu-iotests/150.out.qcow2
 similarity index 100%
 rename from tests/qemu-iotests/150.out
 rename to tests/qemu-iotests/150.out.qcow2
 diff --git a/tests/qemu-iotests/150.out.raw b/tests/qemu-iotests/150.out.raw
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/150.out.raw
@@ -XXX,XX +XXX,XX @@
 +QA output created by 150
 +
 +=== Mapping sparse conversion ===
 +
 +Offset          Length          File
 +0               0x1000          TEST_DIR/t.IMGFMT
 +
 +=== Mapping non-sparse conversion ===
 +
 +Offset          Length          File
 +0               0x100000        TEST_DIR/t.IMGFMT
 +*** done
 diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/175
 +++ b/tests/qemu-iotests/175
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  # the file size.  This function hides the resulting difference in the
  # stat -c '%b' output.
  # Parameter 1: Number of blocks an empty file occupies
 -# Parameter 2: Image size in bytes
 +# Parameter 2: Minimal number of blocks in an image
 +# Parameter 3: Image size in bytes
  _filter_blocks()
  {
      extra_blocks=$1
 -    img_size=$2
 +    min_blocks=$2
 +    img_size=$3
 -    sed -e "s/blocks=$extra_blocks\\(\$\\|[^0-9]\\)/nothing allocated/" \
 -        -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/everything allocated/"
 +    sed -e "s/blocks=$min_blocks\\(\$\\|[^0-9]\\)/min allocation/" \
 +        -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/max allocation/"
  }
  # get standard environment, filters and checks
@@ -XXX,XX +XXX,XX @@ size=$((1 * 1024 * 1024))
  touch "$TEST_DIR/empty"
  extra_blocks=$(stat -c '%b' "$TEST_DIR/empty")
 +# We always write the first byte; check how many blocks this filesystem
 +# allocates to match empty image alloation.
 +printf "\0" > "$TEST_DIR/empty"
 +min_blocks=$(stat -c '%b' "$TEST_DIR/empty")
 +
  echo
  echo "== creating image with default preallocation =="
  _make_test_img $size | _filter_imgfmt
 -stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
 +stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
  for mode in off full falloc; do
      echo
      echo "== creating image with preallocation $mode =="
      IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt
 -    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
 +    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
  done
  # success, all done
 diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/175.out
 +++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@ QA output created by 175
  == creating image with default preallocation ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576
 -size=1048576, nothing allocated
 +size=1048576, min allocation
  == creating image with preallocation off ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off
 -size=1048576, nothing allocated
 +size=1048576, min allocation
  == creating image with preallocation full ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full
 -size=1048576, everything allocated
 +size=1048576, max allocation
  == creating image with preallocation falloc ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
 -size=1048576, everything allocated
 +size=1048576, max allocation
   *** done
 diff --git a/tests/qemu-iotests/178.out.qcow2 b/tests/qemu-iotests/178.out.qcow2
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/178.out.qcow2
 +++ b/tests/qemu-iotests/178.out.qcow2
@@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608
  == raw input image with data (human) ==
  Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
 -required size: 393216
 +required size: 458752
  fully allocated size: 1074135040
  wrote 512/512 bytes at offset 512
 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608
  Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
  {
 -    "required": 393216,
 +    "required": 458752,
      "fully-allocated": 1074135040
  }
  wrote 512/512 bytes at offset 512
 diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/221.out
 +++ b/tests/qemu-iotests/221.out
@@ -XXX,XX +XXX,XX @@ QA output created by 221
  === Check mapping of unaligned raw image ===
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65537
 -[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 -[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
  wrote 1/1 bytes at offset 65536
 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
  { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 -[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
  { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
  *** done
 diff --git a/tests/qemu-iotests/253.out b/tests/qemu-iotests/253.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/253.out
 +++ b/tests/qemu-iotests/253.out
@@ -XXX,XX +XXX,XX @@ QA output created by 253
  === Check mapping of unaligned raw image ===
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048575
 -[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 -[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
  wrote 65535/65535 bytes at offset 983040
 .999 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
 -[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
  *** done
 --
 .21.0

-[Qemu-devel] [PULL for-2.10 08/15] throttle: Test the valid range of config values
+[Qemu-devel] [PULL v2 04/16] iotests: Test allocate_first_block() with O_DIRECT
-From: Alberto Garcia <berto@igalia.com>
+From: Nir Soffer <nirsof@gmail.com>
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Using block_resize we can test allocate_first_block() with file
-Message-id: a57dd6274e1b6dc9c28769fec4c7ea543be5c5e3.1503580370.git.berto@igalia.com
+descriptor opened with O_DIRECT, ensuring that it works for any size
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+larger than 4096 bytes.
 Testing smaller sizes is tricky as the result depends on the filesystem
 used for testing. For example on NFS any size will work since O_DIRECT
 does not require any alignment.
 Signed-off-by: Nir Soffer <nsoffer@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-id: 20190827010528.8818-3-nsoffer@redhat.com
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/test-throttle.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/175     | 28 ++++++++++++++++++++++++++++
-file changed, 77 insertions(+)
+ tests/qemu-iotests/175.out |  8 ++++++++
 files changed, 36 insertions(+)
-diff --git a/tests/test-throttle.c b/tests/test-throttle.c
+diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
-index XXXXXXX..XXXXXXX 100644
+index XXXXXXX..XXXXXXX 100755
---- a/tests/test-throttle.c
+--- a/tests/qemu-iotests/175
-+++ b/tests/test-throttle.c
++++ b/tests/qemu-iotests/175
-@@ -XXX,XX +XXX,XX @@ static void test_is_valid(void)
+@@ -XXX,XX +XXX,XX @@ _filter_blocks()
-     test_is_valid_for_value(1, true);
+         -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/max allocation/"
  }
-+static void test_ranges(void)
++# Resize image using block_resize.
 +# Parameter 1: image path
 +# Parameter 2: new size
 +_block_resize()
 +{
-+    int i;
++    local path=$1
 +    local size=$2
 +
-+    for (i = 0; i < BUCKETS_COUNT; i++) {
++    $QEMU -qmp stdio -nographic -nodefaults \
-+        LeakyBucket *b = &cfg.buckets[i];
++        -blockdev file,node-name=file,filename=$path,cache.direct=on \
-+        throttle_config_init(&cfg);
++        <<EOF
-+
++{'execute': 'qmp_capabilities'}
-+        /* avg = 0 means throttling is disabled, but the config is valid */
++{'execute': 'block_resize', 'arguments': {'node-name': 'file', 'size': $size}}
-+        b->avg = 0;
++{'execute': 'quit'}
-+        g_assert(throttle_is_valid(&cfg, NULL));
++EOF
 +        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)
+ # get standard environment, filters and checks
- {
+ . ./common.rc
-     int i;
+ . ./common.filter
-@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
+@@ -XXX,XX +XXX,XX @@ _supported_fmt raw
-     g_test_add_func("/throttle/config/enabled",     test_enabled);
+ _supported_proto file
-     g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
+ _supported_os Linux
-     g_test_add_func("/throttle/config/is_valid",    test_is_valid);
-+    g_test_add_func("/throttle/config/ranges",      test_ranges);
++_default_cache_mode none
-     g_test_add_func("/throttle/config/max",         test_max_is_missing_limit);
++_supported_cache_modes none directsync
-     g_test_add_func("/throttle/config/iops_size",
++
-                     test_iops_size_is_missing_limit);
+ size=$((1 * 1024 * 1024))
  touch "$TEST_DIR/empty"
@@ -XXX,XX +XXX,XX @@ for mode in off full falloc; do
      stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
  done
 +for new_size in 4096 1048576; do
 +    echo
 +    echo "== resize empty image with block_resize =="
 +    _make_test_img 0 | _filter_imgfmt
 +    _block_resize $TEST_IMG $new_size >/dev/null
 +    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $new_size
 +done
 +
  # success, all done
  echo "*** done"
  rm -f $seq.full
 diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/175.out
 +++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@ size=1048576, max allocation
  == creating image with preallocation falloc ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
  size=1048576, max allocation
 +
 +== resize empty image with block_resize ==
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
 +size=4096, min allocation
 +
 +== resize empty image with block_resize ==
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
 +size=1048576, min allocation
   *** done
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 14/15] qemu-doc: Add UUID support in initiator name
+[Qemu-devel] [PULL v2 05/16] iotests: Fix _filter_img_create()
-From: Fred Rolland <rollandf@gmail.com>
+fe646693acc changed qemu-img create's output so that it no longer prints
 single quotes around parameter values.  The subformat and adapter_type
 filters in _filter_img_create() have never been adapted to that change.
-Update doc with the usage of UUID for initiator name.
+Fixes: fe646693acc13ac48b98435d14149ab04dc597bc
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Message-id: 20190815153638.4600-2-mreitz@redhat.com
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/059.out       | 16 ++++++++--------
  tests/qemu-iotests/common.filter |  4 ++--
 files changed, 10 insertions(+), 10 deletions(-)
-Related-To: https://bugzilla.redhat.com/1006468
+diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
 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 +++--
 file changed, 3 insertions(+), 2 deletions(-)
 diff --git a/qemu-doc.texi b/qemu-doc.texi
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-doc.texi
+--- a/tests/qemu-iotests/059.out
-+++ b/qemu-doc.texi
++++ b/tests/qemu-iotests/059.out
-@@ -XXX,XX +XXX,XX @@ in a configuration file provided via '-readconfig' or directly on the
+@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
- command line.
+ qemu-io: can't open device TEST_DIR/t.vmdk: L1 size too big
- If the initiator-name is not specified qemu will use a default name
+ === Testing monolithicFlat creation and opening ===
--of 'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
-+of 'iqn.2008-11.org.linux-kvm[:<uuid>'] where <uuid> is the UUID of the
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
-+virtual machine. If the UUID is not specified qemu will use
+ image: TEST_DIR/t.IMGFMT
-+'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+ file format: IMGFMT
- virtual machine.
+ virtual size: 2 GiB (2147483648 bytes)
--
+ === Testing monolithicFlat with zeroed_grain ===
- @example
+ qemu-img: TEST_DIR/t.IMGFMT: Flat image can't enable zeroed grain
- Setting a specific initiator name to use when logging in to the target
+-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
- -iscsi initiator-name=iqn.qemu.test:my-initiator
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
  === Testing big twoGbMaxExtentFlat ===
 -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMaxExtentFlat
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000
  image: TEST_DIR/t.vmdk
  file format: vmdk
  virtual size: 0.977 TiB (1073741824000 bytes)
@@ -XXX,XX +XXX,XX @@ Format specific information:
  qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Invalid extent line: RW 12582912 VMFS "dummy.IMGFMT" 1
  === Testing truncated sparse ===
 -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400 subformat=monolithicSparse
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400
  qemu-img: Could not open 'TEST_DIR/t.IMGFMT': File truncated, expecting at least 13172736 bytes
  === Converting to streamOptimized from image with small cluster size===
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  === Testing monolithicFlat with internally generated JSON file name ===
 -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 subformat=monolithicFlat
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
  qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
  === Testing version 3 ===
@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 64931328
 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  === Testing 4TB monolithicFlat creation and IO ===
 -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 subformat=monolithicFlat
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104
  image: TEST_DIR/t.IMGFMT
  file format: IMGFMT
  virtual size: 4 TiB (4398046511104 bytes)
@@ -XXX,XX +XXX,XX @@ read 1024/1024 bytes at offset 966367641600
 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  === Testing qemu-img map on extents ===
 -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=monolithicSparse
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
  wrote 1024/1024 bytes at offset 65024
 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  wrote 1024/1024 bytes at offset 2147483136
@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
 0x20000         0x3f0000        TEST_DIR/t.vmdk
 x7fff0000      0x20000         0x410000        TEST_DIR/t.vmdk
 x140000000     0x10000         0x430000        TEST_DIR/t.vmdk
 -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=twoGbMaxExtentSparse
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
  wrote 1024/1024 bytes at offset 65024
 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  wrote 1024/1024 bytes at offset 2147483136
 diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/common.filter
 +++ b/tests/qemu-iotests/common.filter
@@ -XXX,XX +XXX,XX @@ _filter_img_create()
          -e "s# compat6=\\(on\\|off\\)##g" \
          -e "s# static=\\(on\\|off\\)##g" \
          -e "s# zeroed_grain=\\(on\\|off\\)##g" \
 -        -e "s# subformat='[^']*'##g" \
 -        -e "s# adapter_type='[^']*'##g" \
 +        -e "s# subformat=[^ ]*##g" \
 +        -e "s# adapter_type=[^ ]*##g" \
          -e "s# hwversion=[^ ]*##g" \
          -e "s# lazy_refcounts=\\(on\\|off\\)##g" \
          -e "s# block_size=[0-9]\\+##g" \
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 13/15] tests: migration/guestperf Python 2.6 argparse compatibility
+[Qemu-devel] [PULL v2 06/16] vmdk: Use bdrv_dirname() for relative extent paths
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+This makes iotest 033 pass with e.g. subformat=monolithicFlat.  It also
-import argparse.
+turns a former error in 059 into success.
-Cc: Daniel P. Berrange <berrange@redhat.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190815153638.4600-3-mreitz@redhat.com
-Acked-by: John Snow <jsnow@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
-Acked-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 Message-id: 20170825155732.15665-4-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/migration/guestperf/shell.py | 8 +++++---
+ block/vmdk.c               | 54 ++++++++++++++++++++++++--------------
-file changed, 5 insertions(+), 3 deletions(-)
+ tests/qemu-iotests/059     |  7 +++--
  tests/qemu-iotests/059.out |  4 ++-
 files changed, 42 insertions(+), 23 deletions(-)
-diff --git a/tests/migration/guestperf/shell.py b/tests/migration/guestperf/shell.py
+diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/migration/guestperf/shell.py
+--- a/block/vmdk.c
-+++ b/tests/migration/guestperf/shell.py
++++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static const char *next_line(const char *s)
- #
+ }
+ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
--import argparse
+-                              const char *desc_file_path, QDict *options,
--import fnmatch
+-                              Error **errp)
- import os
++                              QDict *options, Error **errp)
- import os.path
+ {
--import platform
+     int ret;
- import sys
+     int matches;
-+sys.path.append(os.path.join(os.path.dirname(__file__),
+@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
-+                             '..', '..', '..', 'scripts'))
+     const char *p, *np;
-+import argparse
+     int64_t sectors = 0;
-+import fnmatch
+     int64_t flat_offset;
-+import platform
++    char *desc_file_dir = NULL;
+     char *extent_path;
- from guestperf.hardware import Hardware
+     BdrvChild *extent_file;
- from guestperf.engine import Engine
+     BDRVVmdkState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
              continue;
          }
 -        if (!path_is_absolute(fname) && !path_has_protocol(fname) &&
 -            !desc_file_path[0])
 -        {
 -            bdrv_refresh_filename(bs->file->bs);
 -            error_setg(errp, "Cannot use relative extent paths with VMDK "
 -                       "descriptor file '%s'", bs->file->bs->filename);
 -            return -EINVAL;
 -        }
 +        if (path_is_absolute(fname)) {
 +            extent_path = g_strdup(fname);
 +        } else {
 +            if (!desc_file_dir) {
 +                desc_file_dir = bdrv_dirname(bs->file->bs, errp);
 +                if (!desc_file_dir) {
 +                    bdrv_refresh_filename(bs->file->bs);
 +                    error_prepend(errp, "Cannot use relative paths with VMDK "
 +                                  "descriptor file '%s': ",
 +                                  bs->file->bs->filename);
 +                    ret = -EINVAL;
 +                    goto out;
 +                }
 +            }
 -        extent_path = path_combine(desc_file_path, fname);
 +            extent_path = g_strconcat(desc_file_dir, fname, NULL);
 +        }
          ret = snprintf(extent_opt_prefix, 32, "extents.%d", s->num_extents);
          assert(ret < 32);
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
          g_free(extent_path);
          if (local_err) {
              error_propagate(errp, local_err);
 -            return -EINVAL;
 +            ret = -EINVAL;
 +            goto out;
          }
          /* save to extents array */
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
 , 0, 0, 0, 0, &extent, errp);
              if (ret < 0) {
                  bdrv_unref_child(bs, extent_file);
 -                return ret;
 +                goto out;
              }
              extent->flat_start_offset = flat_offset << 9;
          } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
              g_free(buf);
              if (ret) {
                  bdrv_unref_child(bs, extent_file);
 -                return ret;
 +                goto out;
              }
              extent = &s->extents[s->num_extents - 1];
          } else if (!strcmp(type, "SESPARSE")) {
              ret = vmdk_open_se_sparse(bs, extent_file, bs->open_flags, errp);
              if (ret) {
                  bdrv_unref_child(bs, extent_file);
 -                return ret;
 +                goto out;
              }
              extent = &s->extents[s->num_extents - 1];
          } else {
              error_setg(errp, "Unsupported extent type '%s'", type);
              bdrv_unref_child(bs, extent_file);
 -            return -ENOTSUP;
 +            ret = -ENOTSUP;
 +            goto out;
          }
          extent->type = g_strdup(type);
      }
 -    return 0;
 +
 +    ret = 0;
 +    goto out;
  invalid:
      np = next_line(p);
@@ -XXX,XX +XXX,XX @@ invalid:
          np--;
      }
      error_setg(errp, "Invalid extent line: %.*s", (int)(np - p), p);
 -    return -EINVAL;
 +    ret = -EINVAL;
 +
 +out:
 +    g_free(desc_file_dir);
 +    return ret;
  }
  static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
      }
      s->create_type = g_strdup(ct);
      s->desc_offset = 0;
 -    ret = vmdk_parse_extents(buf, bs, bs->file->bs->exact_filename, options,
 -                             errp);
 +    ret = vmdk_parse_extents(buf, bs, options, errp);
  exit:
      return ret;
  }
 diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/059
 +++ b/tests/qemu-iotests/059
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
  echo
  echo "=== Testing monolithicFlat with internally generated JSON file name ==="
 +# Should work, because bdrv_dirname() works fine with blkdebug
  IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
 -$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" 2>&1 \
 -    | _filter_testdir | _filter_imgfmt
 +$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
 +         -c info \
 +    2>&1 \
 +    | _filter_testdir | _filter_imgfmt | _filter_img_info
  _cleanup_test_img
  echo
 diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/059.out
 +++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
  === Testing monolithicFlat with internally generated JSON file name ===
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 -qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
 +format name: IMGFMT
 +cluster size: 0 bytes
 +vm state offset: 0 bytes
  === Testing version 3 ===
  image: TEST_DIR/iotest-version3.IMGFMT
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 11/15] scripts: add argparse module for Python 2.6 compatibility
+[Qemu-devel] [PULL v2 07/16] iotests: Keep testing broken relative extent paths
-The minimum Python version supported by QEMU is 2.6.  The argparse
+We had a test for a case where relative extent paths did not work, but
-standard library module was only added in Python 2.7.  Many scripts
+unfortunately we just fixed the underlying problem, so it works now.
-would like to use argparse because it supports command-line
+This patch adds a new test case that still fails.
 sub-commands.
-This patch adds argparse.  See the top of argparse.py for details.
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Message-id: 20190815153638.4600-4-mreitz@redhat.com
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/059     | 27 +++++++++++++++++++++++++++
  tests/qemu-iotests/059.out |  4 ++++
 files changed, 31 insertions(+)
-Suggested-by: Daniel P. Berrange <berrange@redhat.com>
+diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+index XXXXXXX..XXXXXXX 100755
-Acked-by: John Snow <jsnow@redhat.com>
+--- a/tests/qemu-iotests/059
-Message-id: 20170825155732.15665-2-stefanha@redhat.com
++++ b/tests/qemu-iotests/059
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
----
- COPYING.PYTHON      |  270 ++++++
+ echo
- scripts/argparse.py | 2406 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ echo "=== Testing monolithicFlat with internally generated JSON file name ==="
 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
++echo '--- blkdebug ---'
-+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+ # Should work, because bdrv_dirname() works fine with blkdebug
-+as a successor of a language called ABC.  Guido remains Python's
+ IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
-+principal author, although it includes many contributions from others.
+ $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TE
      | _filter_testdir | _filter_imgfmt | _filter_img_info
  _cleanup_test_img
 +echo '--- quorum ---'
 +# Should not work, because bdrv_dirname() does not work with quorum
 +IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
 +cp "$TEST_IMG" "$TEST_IMG.orig"
 +
-+In 1995, Guido continued his work on Python at the Corporation for
++filename="json:{
-+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
++    \"driver\": \"$IMGFMT\",
-+in Reston, Virginia where he released several versions of the
++    \"file\": {
-+software.
++        \"driver\": \"quorum\",
 +        \"children\": [ {
 +            \"driver\": \"file\",
 +            \"filename\": \"$TEST_IMG\"
 +        }, {
 +            \"driver\": \"file\",
 +            \"filename\": \"$TEST_IMG.orig\"
 +        } ],
 +        \"vote-threshold\": 1
 +    } }"
 +
-+In May 2000, Guido and the Python core development team moved to
++filename=$(echo "$filename" | tr '\n' ' ' | sed -e 's/\s\+/ /g')
-+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
++$QEMU_IMG info "$filename" 2>&1 \
-+year, the PythonLabs team moved to Digital Creations (now Zope
++    | sed -e "s/'json:[^']*'/\$QUORUM_FILE/g" \
-+Corporation, see http://www.zope.com).  In 2001, the Python Software
++    | _filter_testdir | _filter_imgfmt | _filter_img_info
 +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
+ echo
-+===============================================================
+ echo "=== Testing version 3 ==="
-+
+ _use_sample_img iotest-version3.vmdk.bz2
-+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
-+--------------------------------------------
+index XXXXXXX..XXXXXXX 100644
-+
+--- a/tests/qemu-iotests/059.out
-+1. This LICENSE AGREEMENT is between the Python Software Foundation
++++ b/tests/qemu-iotests/059.out
-+("PSF"), and the Individual or Organization ("Licensee") accessing and
+@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
-+otherwise using this software ("Python") in source or binary form and
+bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+its associated documentation.
-+
+ === Testing monolithicFlat with internally generated JSON file name ===
-+2. Subject to the terms and conditions of this License Agreement, PSF
++--- blkdebug ---
-+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
-+license to reproduce, analyze, test, perform and/or display publicly,
+ format name: IMGFMT
-+prepare derivative works, distribute, and otherwise use Python
+ cluster size: 0 bytes
-+alone or in any derivative version, provided, however, that PSF's
+ vm state offset: 0 bytes
-+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
++--- quorum ---
-+2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
-+Reserved" are retained in Python alone or in any derivative version
++qemu-img: Could not open $QUORUM_FILE: Cannot use relative paths with VMDK descriptor file $QUORUM_FILE: Cannot generate a base directory for quorum nodes
-+prepared by Licensee.
-+
+ === Testing version 3 ===
-+3. In the event Licensee prepares a derivative work that is based on
+ image: TEST_DIR/iotest-version3.IMGFMT
 +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))
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 07/15] throttle: Make burst_length 64bit and add range checks
+[Qemu-devel] [PULL v2 08/16] vmdk: Reject invalid compressed writes
-From: Alberto Garcia <berto@igalia.com>
+Compressed writes generally have to write full clusters, not just in
 theory but also in practice when it comes to vmdk's streamOptimized
 subformat.  It currently is just silently broken for writes with
 non-zero in-cluster offsets:
-LeakyBucket.burst_length is defined as an unsigned integer but the
+$ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
-code never checks for overflows and it only makes sure that the value
+$ qemu-io -c 'write 4k 4k' -c 'read 4k 4k' foo.vmdk
-is not 0.
+wrote 4096/4096 bytes at offset 4096
 KiB, 1 ops; 00.01 sec (443.724 KiB/sec and 110.9309 ops/sec)
 read failed: Invalid argument
-In practice this means that the user can set something like
+(The technical reason is that vmdk_write_extent() just writes the
-throttling.iops-total-max-length=4294967300 despite being larger than
+incomplete compressed data actually to offset 4k.  When reading the
-UINT_MAX and the final value after casting to unsigned int will be 4.
+data, vmdk_read_extent() looks at offset 0 and finds the compressed data
 size to be 0, because that is what it reads from there.  This yields an
 error.)
-This patch changes the data type to uint64_t. This does not increase
+For incomplete writes with zero in-cluster offsets, the error path when
-the storage size of LeakyBucket, and allows us to assign the value
+reading the rest of the cluster is a bit different, but the result is
-directly from qemu_opt_get_number() or BlockIOThrottle and then do the
+the same:
 checks directly in throttle_is_valid().
-The value of burst_length does not have a specific upper limit,
+$ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
-but since the bucket size is defined by max * burst_length we have
+$ qemu-io -c 'write 0k 4k' -c 'read 4k 4k' foo.vmdk
-to prevent overflows. Instead of going for UINT64_MAX or something
+wrote 4096/4096 bytes at offset 0
-similar this patch reuses THROTTLE_VALUE_MAX, which allows I/O bursts
+KiB, 1 ops; 00.01 sec (362.641 KiB/sec and 90.6603 ops/sec)
-of 1 GiB/s for 10 days in a row.
+read failed: Invalid argument
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+(Here, vmdk_read_extent() finds the data and then sees that the
-Message-id: 1b2e3049803f71cafb2e1fa1be4fb47147a0d398.1503580370.git.berto@igalia.com
+uncompressed data is short.)
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 It is better to reject invalid writes than to make the user believe they
 might have succeeded and then fail when trying to read it back.
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Message-id: 20190815153638.4600-5-mreitz@redhat.com
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- include/qemu/throttle.h | 2 +-
+ block/vmdk.c | 10 ++++++++++
- util/throttle.c         | 5 +++++
+file changed, 10 insertions(+)
 files changed, 6 insertions(+), 1 deletion(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/block/vmdk.c
-+++ b/include/qemu/throttle.h
++++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@ typedef struct LeakyBucket {
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
-     uint64_t max;             /* leaky bucket max burst in units */
+     if (extent->compressed) {
-     double  level;            /* bucket level in units */
+         void *compressed_data;
-     double  burst_level;      /* bucket level in units (for computing bursts) */
--    unsigned burst_length;    /* max length of the burst period, in seconds */
++        /* Only whole clusters */
-+    uint64_t burst_length;    /* max length of the burst period, in seconds */
++        if (offset_in_cluster ||
- } LeakyBucket;
++            n_bytes > (extent->cluster_sectors * SECTOR_SIZE) ||
++            (n_bytes < (extent->cluster_sectors * SECTOR_SIZE) &&
- /* The following structure is used to configure a ThrottleState
++             offset + n_bytes != extent->end_sector * SECTOR_SIZE))
-diff --git a/util/throttle.c b/util/throttle.c
++        {
-index XXXXXXX..XXXXXXX 100644
++            ret = -EINVAL;
---- a/util/throttle.c
++            goto out;
 +++ 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) {
+         if (!extent->has_marker) {
-             error_setg(errp, "bps_max/iops_max require corresponding"
+             ret = -EINVAL;
-                        " bps/iops values");
+             goto out;
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 04/15] throttle: Make throttle_is_valid() a bit less verbose
+[Qemu-devel] [PULL v2 09/16] iotests: Disable broken streamOptimized tests
-From: Alberto Garcia <berto@igalia.com>
+streamOptimized does not support writes that do not span exactly one
 cluster.  Furthermore, it cannot rewrite already allocated clusters.
 As such, many iotests do not work with it.  Disable them.
-Use a pointer to the bucket instead of repeating cfg->buckets[i] all
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-the time. This makes the code more concise and will help us expand the
+Message-id: 20190815153638.4600-6-mreitz@redhat.com
-checks later and save a few line breaks.
+Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/002 | 1 +
  tests/qemu-iotests/003 | 1 +
  tests/qemu-iotests/005 | 3 ++-
  tests/qemu-iotests/009 | 1 +
  tests/qemu-iotests/010 | 1 +
  tests/qemu-iotests/011 | 1 +
  tests/qemu-iotests/017 | 3 ++-
  tests/qemu-iotests/018 | 3 ++-
  tests/qemu-iotests/019 | 3 ++-
  tests/qemu-iotests/020 | 3 ++-
  tests/qemu-iotests/027 | 1 +
  tests/qemu-iotests/032 | 1 +
  tests/qemu-iotests/033 | 1 +
  tests/qemu-iotests/034 | 3 ++-
  tests/qemu-iotests/037 | 3 ++-
  tests/qemu-iotests/063 | 3 ++-
  tests/qemu-iotests/072 | 1 +
  tests/qemu-iotests/105 | 3 ++-
  tests/qemu-iotests/197 | 1 +
  tests/qemu-iotests/215 | 1 +
  tests/qemu-iotests/251 | 1 +
 files changed, 30 insertions(+), 9 deletions(-)
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+diff --git a/tests/qemu-iotests/002 b/tests/qemu-iotests/002
-Message-id: 763ffc40a26b17d54cf93f5a999e4656049fcf0c.1503580370.git.berto@igalia.com
+index XXXXXXX..XXXXXXX 100755
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+--- a/tests/qemu-iotests/002
----
++++ b/tests/qemu-iotests/002
- util/throttle.c | 15 +++++++--------
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
-file changed, 7 insertions(+), 8 deletions(-)
+ _supported_fmt generic
-diff --git a/util/throttle.c b/util/throttle.c
+ _supported_proto generic
-index XXXXXXX..XXXXXXX 100644
++_unsupported_imgopts "subformat=streamOptimized"
---- a/util/throttle.c
-+++ b/util/throttle.c
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
+ size=128M
-     }
+diff --git a/tests/qemu-iotests/003 b/tests/qemu-iotests/003
+index XXXXXXX..XXXXXXX 100755
-     for (i = 0; i < BUCKETS_COUNT; i++) {
+--- a/tests/qemu-iotests/003
--        if (cfg->buckets[i].avg < 0 ||
++++ b/tests/qemu-iotests/003
--            cfg->buckets[i].max < 0 ||
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
--            cfg->buckets[i].avg > THROTTLE_VALUE_MAX ||
--            cfg->buckets[i].max > THROTTLE_VALUE_MAX) {
+ _supported_fmt generic
-+        LeakyBucket *bkt = &cfg->buckets[i];
+ _supported_proto generic
-+        if (bkt->avg < 0 || bkt->max < 0 ||
++_unsupported_imgopts "subformat=streamOptimized"
-+            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
-             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
+ size=128M
-                        THROTTLE_VALUE_MAX);
+ offset=67M
-             return false;
+diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005
-         }
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/005
--        if (!cfg->buckets[i].burst_length) {
++++ b/tests/qemu-iotests/005
-+        if (!bkt->burst_length) {
+@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
-             error_setg(errp, "the burst length cannot be 0");
+ _supported_proto generic
-             return false;
+ _supported_os Linux
-         }
+ _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
+-                     "subformat=twoGbMaxExtentSparse"
--        if (cfg->buckets[i].burst_length > 1 && !cfg->buckets[i].max) {
++                     "subformat=twoGbMaxExtentSparse" \
-+        if (bkt->burst_length > 1 && !bkt->max) {
++                     "subformat=streamOptimized"
-             error_setg(errp, "burst length set without burst rate");
-             return false;
+ # vpc is limited to 127GB, so we can't test it here
-         }
+ if [ "$IMGFMT" = "vpc" ]; then
+diff --git a/tests/qemu-iotests/009 b/tests/qemu-iotests/009
--        if (cfg->buckets[i].max && !cfg->buckets[i].avg) {
+index XXXXXXX..XXXXXXX 100755
-+        if (bkt->max && !bkt->avg) {
+--- a/tests/qemu-iotests/009
-             error_setg(errp, "bps_max/iops_max require corresponding"
++++ b/tests/qemu-iotests/009
-                        " bps/iops values");
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
-             return false;
-         }
+ _supported_fmt generic
+ _supported_proto generic
--        if (cfg->buckets[i].max && cfg->buckets[i].max < cfg->buckets[i].avg) {
++_unsupported_imgopts "subformat=streamOptimized"
-+        if (bkt->max && bkt->max < bkt->avg) {
-             error_setg(errp, "bps_max/iops_max cannot be lower than bps/iops");
-             return false;
+ size=6G
-         }
+diff --git a/tests/qemu-iotests/010 b/tests/qemu-iotests/010
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/010
 +++ b/tests/qemu-iotests/010
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt generic
  _supported_proto generic
 +_unsupported_imgopts "subformat=streamOptimized"
  size=6G
 diff --git a/tests/qemu-iotests/011 b/tests/qemu-iotests/011
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/011
 +++ b/tests/qemu-iotests/011
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt generic
  _supported_proto generic
 +_unsupported_imgopts "subformat=streamOptimized"
  size=6G
 diff --git a/tests/qemu-iotests/017 b/tests/qemu-iotests/017
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/017
 +++ b/tests/qemu-iotests/017
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow qcow2 vmdk qed
  _supported_proto generic
  _unsupported_proto vxhs
 -_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
 +_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
 +                     "subformat=streamOptimized"
  TEST_OFFSETS="0 4294967296"
 diff --git a/tests/qemu-iotests/018 b/tests/qemu-iotests/018
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/018
 +++ b/tests/qemu-iotests/018
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow qcow2 vmdk qed
  _supported_proto file
  _supported_os Linux
 -_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
 +_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
 +                     "streamOptimized"
  TEST_OFFSETS="0 4294967296"
 diff --git a/tests/qemu-iotests/019 b/tests/qemu-iotests/019
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/019
 +++ b/tests/qemu-iotests/019
@@ -XXX,XX +XXX,XX @@ _supported_proto file
  _supported_os Linux
  _unsupported_imgopts "subformat=monolithicFlat" \
                       "subformat=twoGbMaxExtentFlat" \
 -                     "subformat=twoGbMaxExtentSparse"
 +                     "subformat=twoGbMaxExtentSparse" \
 +                     "subformat=streamOptimized"
  TEST_OFFSETS="0 4294967296"
  CLUSTER_SIZE=65536
 diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/020
 +++ b/tests/qemu-iotests/020
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed
  _supported_proto file
  _unsupported_imgopts "subformat=monolithicFlat" \
                       "subformat=twoGbMaxExtentFlat" \
 -                     "subformat=twoGbMaxExtentSparse"
 +                     "subformat=twoGbMaxExtentSparse" \
 +                     "subformat=streamOptimized"
  TEST_OFFSETS="0 4294967296"
 diff --git a/tests/qemu-iotests/027 b/tests/qemu-iotests/027
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/027
 +++ b/tests/qemu-iotests/027
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt vmdk qcow qcow2 qed
  _supported_proto generic
 +_unsupported_imgopts "subformat=streamOptimized"
  size=128M
 diff --git a/tests/qemu-iotests/032 b/tests/qemu-iotests/032
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/032
 +++ b/tests/qemu-iotests/032
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  # This works for any image format (though unlikely to segfault for raw)
  _supported_fmt generic
  _supported_proto generic
 +_unsupported_imgopts "subformat=streamOptimized"
  echo
  echo === Prepare image ===
 diff --git a/tests/qemu-iotests/033 b/tests/qemu-iotests/033
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/033
 +++ b/tests/qemu-iotests/033
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt generic
  _supported_proto generic
 +_unsupported_imgopts "subformat=streamOptimized"
  size=128M
 diff --git a/tests/qemu-iotests/034 b/tests/qemu-iotests/034
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/034
 +++ b/tests/qemu-iotests/034
@@ -XXX,XX +XXX,XX @@ _supported_proto file
  _supported_os Linux
  _unsupported_imgopts "subformat=monolithicFlat" \
                       "subformat=twoGbMaxExtentFlat" \
 -                     "subformat=twoGbMaxExtentSparse"
 +                     "subformat=twoGbMaxExtentSparse" \
 +                     "subformat=streamOptimized"
  CLUSTER_SIZE=4k
  size=128M
 diff --git a/tests/qemu-iotests/037 b/tests/qemu-iotests/037
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/037
 +++ b/tests/qemu-iotests/037
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed
  _supported_proto file
  _unsupported_imgopts "subformat=monolithicFlat" \
                       "subformat=twoGbMaxExtentFlat" \
 -                     "subformat=twoGbMaxExtentSparse"
 +                     "subformat=twoGbMaxExtentSparse" \
 +                     "subformat=streamOptimized"
  CLUSTER_SIZE=4k
  size=128M
 diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/063
 +++ b/tests/qemu-iotests/063
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed raw
  _supported_proto file
  _unsupported_imgopts "subformat=monolithicFlat" \
                       "subformat=twoGbMaxExtentFlat" \
 -                     "subformat=twoGbMaxExtentSparse"
 +                     "subformat=twoGbMaxExtentSparse" \
 +                     "subformat=streamOptimized"
  _make_test_img 4M
 diff --git a/tests/qemu-iotests/072 b/tests/qemu-iotests/072
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/072
 +++ b/tests/qemu-iotests/072
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt vpc vmdk vhdx vdi qed qcow2 qcow
  _supported_proto file
 +_unsupported_imgopts "subformat=streamOptimized"
  IMG_SIZE=64M
 diff --git a/tests/qemu-iotests/105 b/tests/qemu-iotests/105
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/105
 +++ b/tests/qemu-iotests/105
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2 vmdk vhdx qed
  _supported_proto generic
  _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
 -                     "subformat=twoGbMaxExtentSparse"
 +                     "subformat=twoGbMaxExtentSparse" \
 +                     "subformat=streamOptimized"
  echo
  echo "creating large image"
 diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/197
 +++ b/tests/qemu-iotests/197
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
  _supported_proto generic
  # LUKS support may be possible, but it complicates things.
  _unsupported_fmt luks
 +_unsupported_imgopts "subformat=streamOptimized"
  echo
  echo '=== Copy-on-read ==='
 diff --git a/tests/qemu-iotests/215 b/tests/qemu-iotests/215
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/215
 +++ b/tests/qemu-iotests/215
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
  _supported_proto generic
  # LUKS support may be possible, but it complicates things.
  _unsupported_fmt luks
 +_unsupported_imgopts "subformat=streamOptimized"
  echo
  echo '=== Copy-on-read ==='
 diff --git a/tests/qemu-iotests/251 b/tests/qemu-iotests/251
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/251
 +++ b/tests/qemu-iotests/251
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt generic
  _supported_proto file
  _supported_os Linux
 +_unsupported_imgopts "subformat=streamOptimized"
  if [ "$IMGOPTSSYNTAX" = "true" ]; then
      # We use json:{} filenames here, so we cannot work with additional options.
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 12/15] docker.py: Python 2.6 argparse compatibility
+[Qemu-devel] [PULL v2 10/16] iotests: Disable 110 for vmdk.twoGbMaxExtentSparse
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+The error message for the test case where we have a quorum node for
-import argparse.
+which no directory name can be generated is different: For
 twoGbMaxExtentSparse, it complains that it cannot open the extent file.
 For other (sub)formats, it just notes that it cannot determine the
 backing file path.  Both are fine, but just disable twoGbMaxExtentSparse
 for simplicity's sake.
-Cc: Fam Zheng <famz@redhat.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
-Acked-by: John Snow <jsnow@redhat.com>
+Message-id: 20190815153638.4600-7-mreitz@redhat.com
-Acked-by: Fam Zheng <famz@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 20170825155732.15665-3-stefanha@redhat.com
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/docker/docker.py | 4 +++-
+ tests/qemu-iotests/110 | 3 ++-
-file changed, 3 insertions(+), 1 deletion(-)
+file changed, 2 insertions(+), 1 deletion(-)
-diff --git a/tests/docker/docker.py b/tests/docker/docker.py
+diff --git a/tests/qemu-iotests/110 b/tests/qemu-iotests/110
 index XXXXXXX..XXXXXXX 100755
---- a/tests/docker/docker.py
+--- a/tests/qemu-iotests/110
-+++ b/tests/docker/docker.py
++++ b/tests/qemu-iotests/110
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ # Any format supporting backing files
- import os
+ _supported_fmt qed qcow qcow2 vmdk
- import sys
+ _supported_proto file
-+sys.path.append(os.path.join(os.path.dirname(__file__),
+-_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
-+                             '..', '..', 'scripts'))
++_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
-+import argparse
++                     "subformat=twoGbMaxExtentSparse"
- import subprocess
- import json
+ TEST_IMG_REL=$(basename "$TEST_IMG")
- import hashlib
  import atexit
  import uuid
 -import argparse
  import tempfile
  import re
  import signal
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 09/15] oslib-posix: Print errors before aborting on qemu_alloc_stack()
+[Qemu-devel] [PULL v2 11/16] iotests: Disable 126 for flat vmdk subformats
-From: Eduardo Habkost <ehabkost@redhat.com>
+iotest 126 requires backing file support, which flat vmdks cannot offer.
 Skip this test for such subformats.
-If QEMU is running on a system that's out of memory and mmap()
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-fails, QEMU aborts with no error message at all, making it hard
+Message-id: 20190815153638.4600-8-mreitz@redhat.com
-to debug the reason for the failure.
+Reviewed-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 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 ++
+ tests/qemu-iotests/126 | 2 ++
 file changed, 2 insertions(+)
-diff --git a/util/oslib-posix.c b/util/oslib-posix.c
+diff --git a/tests/qemu-iotests/126 b/tests/qemu-iotests/126
-index XXXXXXX..XXXXXXX 100644
+index XXXXXXX..XXXXXXX 100755
---- a/util/oslib-posix.c
+--- a/tests/qemu-iotests/126
-+++ b/util/oslib-posix.c
++++ b/tests/qemu-iotests/126
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
-     ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
-                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ # Needs backing file support
-     if (ptr == MAP_FAILED) {
+ _supported_fmt qcow qcow2 qed vmdk
-+        perror("failed to allocate memory for stack");
++_unsupported_imgopts "subformat=monolithicFlat" \
-         abort();
++                     "subformat=twoGbMaxExtentFlat"
-     }
+ # This is the default protocol (and we want to test the difference between
+ # colons which separate a protocol prefix from the rest and colons which are
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+ # just part of the filename, so we cannot test protocols which require a prefix)
      guardpage = ptr;
  #endif
      if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
 +        perror("failed to set up stack guard page");
          abort();
      }
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 02/15] throttle: Fix wrong variable name in the header documentation
+[Qemu-devel] [PULL v2 12/16] file-posix: fix request_alignment typo
-From: Alberto Garcia <berto@igalia.com>
+From: Stefan Hajnoczi <stefanha@redhat.com>
-The level of the burst bucket is stored in bkt.burst_level, not
+Fixes: a6b257a08e3d72219f03e461a52152672fec0612
-bkt.burst_length.
+       ("file-posix: Handle undetectable alignment")
 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>
+Message-id: 20190827101328.4062-1-stefanha@redhat.com
+Reviewed-by: Thomas Huth <thuth@redhat.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- include/qemu/throttle.h | 2 +-
+ block/file-posix.c | 2 +-
 file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/block/file-posix.c
-+++ b/include/qemu/throttle.h
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
-  * - The bkt.avg rate does not apply until the bucket is full,
+         for (i = 0; i < ARRAY_SIZE(alignments); i++) {
-  *   allowing the user to do bursts until then. The I/O limit during
+             align = alignments[i];
-  *   bursts is bkt.max. To enforce this limit we keep an additional
+             if (raw_is_io_aligned(fd, buf + align, max_align)) {
-- *   bucket in bkt.burst_length that leaks at a rate of bkt.max units
+-                /* Fallback to request_aligment. */
-+ *   bucket in bkt.burst_level that leaks at a rate of bkt.max units
++                /* Fallback to request_alignment. */
-  *   per second.
+                 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
-  *
+                 break;
-  * - Because of all of the above, the user can perform I/O at a
+             }
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 10/15] misc: Remove unused Error variables
+[Qemu-devel] [PULL v2 13/16] iotests: Add -display none to the qemu options
-From: Alberto Garcia <berto@igalia.com>
+Without this argument, qemu will print an angry message about not being
 able to connect to a display server if $DISPLAY is not set.  For me,
 that breaks iotests.supported_formats() because it thus only sees
 ["Could", "not", "connect"] as the supported formats.
-There's a few cases which we're passing an Error pointer to a function
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-only to discard it immediately afterwards without checking it. In
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-these cases we can simply remove the variable and pass NULL instead.
+Message-id: 20190819201851.24418-2-mreitz@redhat.com
 Reviewed-by: Thomas Huth <thuth@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/check | 6 +++---
 file changed, 3 insertions(+), 3 deletions(-)
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+index XXXXXXX..XXXXXXX 100755
-Reviewed-by: Eric Blake <eblake@redhat.com>
+--- a/tests/qemu-iotests/check
-Message-id: 20170829120836.16091-1-berto@igalia.com
++++ b/tests/qemu-iotests/check
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+@@ -XXX,XX +XXX,XX @@ export QEMU_PROG="$(type -p "$QEMU_PROG")"
----
- block/qcow.c  | 12 +++---------
+ case "$QEMU_PROG" in
- block/qcow2.c |  8 ++------
+     *qemu-system-arm|*qemu-system-aarch64)
- dump.c        |  4 +---
+-        export QEMU_OPTIONS="-nodefaults -machine virt,accel=qtest"
-files changed, 6 insertions(+), 18 deletions(-)
++        export QEMU_OPTIONS="-nodefaults -display none -machine virt,accel=qtest"
+         ;;
-diff --git a/block/qcow.c b/block/qcow.c
+     *qemu-system-tricore)
-index XXXXXXX..XXXXXXX 100644
+-        export QEMU_OPTIONS="-nodefaults -machine tricore_testboard,accel=qtest"
---- a/block/qcow.c
++        export QEMU_OPTIONS="-nodefaults -display none -machine tricore_testboard,accel=qtest"
-+++ b/block/qcow.c
+         ;;
-@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
+     *)
-                     start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
+-        export QEMU_OPTIONS="-nodefaults -machine accel=qtest"
-                     for(i = 0; i < s->cluster_sectors; i++) {
++        export QEMU_OPTIONS="-nodefaults -display none -machine accel=qtest"
-                         if (i < n_start || i >= n_end) {
+         ;;
--                            Error *err = NULL;
+ esac
                              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;
  }
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 06/15] throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
+[Qemu-devel] [PULL v2 14/16] iotests: Check for enabled drivers before testing them
-From: Alberto Garcia <berto@igalia.com>
+From: Thomas Huth <thuth@redhat.com>
-Both the throttling limits set with the throttling.iops-* and
+It is possible to enable only a subset of the block drivers with the
-throttling.bps-* options and their QMP equivalents defined in the
+"--block-drv-rw-whitelist" option of the "configure" script. All other
-BlockIOThrottle struct are integer values.
+drivers are marked as unusable (or only included as read-only with the
 "--block-drv-ro-whitelist" option). If an iotest is now using such a
 disabled block driver, it is failing - which is bad, since at least the
 tests in the "auto" group should be able to deal with this situation.
 Thus let's introduce a "_require_drivers" function that can be used by
 the shell tests to check for the availability of certain drivers first,
 and marks the test as "not run" if one of the drivers is missing.
-Those limits are also reported in the BlockDeviceInfo struct and they
+This patch mainly targets the test in the "auto" group which should
-are integers there as well.
+never fail in such a case, but also improves some of the other tests
 along the way. Note that we also assume that the "qcow2" and "file"
 drivers are always available - otherwise it does not make sense to
 run "make check-block" at all (which only tests with qcow2 by default).
-Therefore there's no reason to store them internally as double and do
+Signed-off-by: Thomas Huth <thuth@redhat.com>
-the conversion everytime we're setting or querying them, so this patch
+Message-id: 20190823133552.11680-1-thuth@redhat.com
-uses uint64_t for those types. Let's also use an unsigned type because
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-we don't allow negative values anyway.
+---
  tests/qemu-iotests/071       |  1 +
  tests/qemu-iotests/081       |  4 +---
  tests/qemu-iotests/099       |  1 +
  tests/qemu-iotests/120       |  1 +
  tests/qemu-iotests/162       |  4 +---
  tests/qemu-iotests/184       |  1 +
  tests/qemu-iotests/186       |  1 +
  tests/qemu-iotests/common.rc | 14 ++++++++++++++
 files changed, 21 insertions(+), 6 deletions(-)
-LeakyBucket.level and LeakyBucket.burst_level do however remain double
+diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071
-because their value changes depending on the fraction of time elapsed
+index XXXXXXX..XXXXXXX 100755
-since the previous I/O operation.
+--- a/tests/qemu-iotests/071
++++ b/tests/qemu-iotests/071
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
-Message-id: f29b840422767b5be2c41c2dfdbbbf6c5f8fedf8.1503580370.git.berto@igalia.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+ _supported_fmt qcow2
----
+ _supported_proto file
- include/qemu/throttle.h | 4 ++--
++_require_drivers blkdebug blkverify
- tests/test-throttle.c   | 3 ++-
- util/throttle.c         | 7 +++----
+ do_run_qemu()
-files changed, 7 insertions(+), 7 deletions(-)
+ {
+diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/081
 +++ b/tests/qemu-iotests/081
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt raw
  _supported_proto file
  _supported_os Linux
 +_require_drivers quorum
  do_run_qemu()
  {
@@ -XXX,XX +XXX,XX @@ run_qemu()
                            | _filter_qemu_io | _filter_generated_node_ids
  }
 -test_quorum=$($QEMU_IMG --help|grep quorum)
 -[ "$test_quorum" = "" ] && _supported_fmt quorum
 -
  quorum="driver=raw,file.driver=quorum,file.vote-threshold=2"
  quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
  quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
 diff --git a/tests/qemu-iotests/099 b/tests/qemu-iotests/099
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/099
 +++ b/tests/qemu-iotests/099
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow qcow2 qed vdi vhdx vmdk vpc
  _supported_proto file
  _supported_os Linux
 +_require_drivers blkdebug blkverify
  _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
      "subformat=twoGbMaxExtentSparse"
 diff --git a/tests/qemu-iotests/120 b/tests/qemu-iotests/120
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/120
 +++ b/tests/qemu-iotests/120
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt generic
  _supported_proto file
  _unsupported_fmt luks
 +_require_drivers raw
  _make_test_img 64M
 diff --git a/tests/qemu-iotests/162 b/tests/qemu-iotests/162
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/162
 +++ b/tests/qemu-iotests/162
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  . ./common.filter
  _supported_fmt generic
 -
 -test_ssh=$($QEMU_IMG --help | grep '^Supported formats:.* ssh\( \|$\)')
 -[ "$test_ssh" = "" ] && _notrun "ssh support required"
 +_require_drivers ssh
  echo
  echo '=== NBD ==='
 diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/184
 +++ b/tests/qemu-iotests/184
@@ -XXX,XX +XXX,XX @@ trap "exit \$status" 0 1 2 3 15
  . ./common.filter
  _supported_os Linux
 +_require_drivers throttle
  do_run_qemu()
  {
 diff --git a/tests/qemu-iotests/186 b/tests/qemu-iotests/186
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/186
 +++ b/tests/qemu-iotests/186
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto file
 +_require_drivers null-co
  if [ "$QEMU_DEFAULT_MACHINE" != "pc" ]; then
      _notrun "Requires a PC machine"
 diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/tests/qemu-iotests/common.rc
-+++ b/include/qemu/throttle.h
++++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ _require_command()
-  */
+     [ -x "$c" ] || _notrun "$1 utility required, skipped this test"
  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
++# Check that a set of drivers has been whitelisted in the QEMU binary
-index XXXXXXX..XXXXXXX 100644
++#
---- a/util/throttle.c
++_require_drivers()
-+++ b/util/throttle.c
++{
-@@ -XXX,XX +XXX,XX @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
++    available=$($QEMU -drive format=help | \
-         /* If bkt->max is 0 we still want to allow short bursts of I/O
++                sed -e '/Supported formats:/!d' -e 's/Supported formats://')
-          * from the guest, otherwise every other request will be throttled
++    for driver
-          * and performance will suffer considerably. */
++    do
--        bucket_size = bkt->avg / 10;
++        if ! echo "$available" | grep -q " $driver\( \|$\)"; then
-+        bucket_size = (double) bkt->avg / 10;
++            _notrun "$driver not available"
-         burst_bucket_size = 0;
++        fi
-     } else {
++    done
-         /* 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;
+ # make sure this script returns success
--        burst_bucket_size = bkt->max / 10;
+ true
 +        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;
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 03/15] throttle: Update the throttle_fix_bucket() documentation
+[Qemu-devel] [PULL v2 15/16] tests/check-block: Skip iotests when sanitizers are enabled
-From: Alberto Garcia <berto@igalia.com>
+From: Thomas Huth <thuth@redhat.com>
-The way the throttling algorithm works is that requests start being
+The sanitizers (especially the address sanitizer from Clang) are
-throttled once the bucket level exceeds the burst limit. When we get
+sometimes printing out warnings or false positives - this spoils
-there the bucket leaks at the level set by the user (bkt->avg), and
+the output of the iotests, causing some of the tests to fail.
-that leak rate is what prevents guest I/O from exceeding the desired
+Thus let's skip the automatic iotests during "make check" when the
-limit.
+user configured QEMU with --enable-sanitizers.
-If we don't allow bursts (i.e. bkt->max == 0) then we can start
+Signed-off-by: Thomas Huth <thuth@redhat.com>
-throttling requests immediately. The problem with keeping the
+Message-id: 20190823084203.29734-1-thuth@redhat.com
-threshold at 0 is that it only allows one request at a time, and as
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-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
+ tests/check-block.sh | 5 +++++
-make the guest unable to reach the throttle limit if that limit is
+file changed, 5 insertions(+)
 high enough, and that happens regardless of the block scheduler used
 by the guest.
-Increasing that threshold gives flexibility to the guest, allowing it
+diff --git a/tests/check-block.sh b/tests/check-block.sh
-to perform short bursts of I/O before being throttled. Increasing the
+index XXXXXXX..XXXXXXX 100755
-threshold too much does not make a difference in the long run (because
+--- a/tests/check-block.sh
-it's the leak rate what defines the actual throughput) but it does
++++ b/tests/check-block.sh
-allow the guest to perform longer initial bursts and exceed the
+@@ -XXX,XX +XXX,XX @@ if grep -q "TARGET_GPROF=y" *-softmmu/config-target.mak 2>/dev/null ; then
-throttle limit for a short while.
+     exit 0
+ fi
-A burst value of bkt->avg / 10 allows the guest to perform 100ms'
-worth of I/O at the target rate without being throttled.
++if grep -q "CFLAGS.*-fsanitize" config-host.mak 2>/dev/null ; then
++    echo "Sanitizers are enabled ==> Not running the qemu-iotests."
-Signed-off-by: Alberto Garcia <berto@igalia.com>
++    exit 0
-Message-id: 31aae6645f0d1fbf3860fb2b528b757236f0c0a7.1503580370.git.berto@igalia.com
++fi
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
++
----
+ if [ -z "$(find . -name 'qemu-system-*' -print)" ]; then
- util/throttle.c | 11 +++--------
+     echo "No qemu-system binary available ==> Not running the qemu-iotests."
-file changed, 3 insertions(+), 8 deletions(-)
+     exit 0
 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;
 --
-.13.5
+.21.0

-[Qemu-devel] [PULL for-2.10 01/15] nvme: Fix get/set number of queues feature, again
+[Qemu-devel] [PULL v2 16/16] iotests: Unify cache mode quoting
-From: Dan Aloni <dan@kernelim.com>
+From: Nir Soffer <nirsof@gmail.com>
-The number of queues that should be return by the admin command should:
+Quoting cache mode is not needed, and most tests use unquoted values.
 Unify all test to use the same style.
-) Only mention the number of non-admin queues.
+Message-id: 20190827173432.7656-1-nsoffer@redhat.com
-) It is zero-based, meaning that '0 == one non-admin queue',
+Signed-off-by: Nir Soffer <nsoffer@redhat.com>
-     '1 == two non-admin queues', and so forth.
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/026 | 4 ++--
  tests/qemu-iotests/039 | 4 ++--
  tests/qemu-iotests/052 | 2 +-
  tests/qemu-iotests/091 | 4 ++--
 files changed, 7 insertions(+), 7 deletions(-)
-Because our `num_queues` means the number of queues _plus_ the admin
+diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026
-queue, then the right calculation for the number returned from the admin
+index XXXXXXX..XXXXXXX 100755
-command is `num_queues - 2`, combining the two requirements mentioned.
+--- a/tests/qemu-iotests/026
++++ b/tests/qemu-iotests/026
-The issue was discovered by reducing num_queues from 64 to 8 and running
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
-a Linux VM with an SMP parameter larger than that (e.g. 22). It tries to
+ # Currently only qcow2 supports rebasing
-utilize all queues, and therefore fails with an invalid queue number
+ _supported_fmt qcow2
-when trying to queue I/Os on the last queue.
+ _supported_proto file
+-_default_cache_mode "writethrough"
-Signed-off-by: Dan Aloni <dan@kernelim.com>
+-_supported_cache_modes "writethrough" "none"
-CC: Alex Friedman <alex@e8storage.com>
++_default_cache_mode writethrough
-CC: Keith Busch <keith.busch@intel.com>
++_supported_cache_modes writethrough none
-CC: Stefan Hajnoczi <stefanha@redhat.com>
+ # The refcount table tests expect a certain minimum width for refcount entries
-Reviewed-by: Keith Busch <keith.busch@intel.com>
+ # (so that the refcount table actually needs to grow); that minimum is 16 bits,
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+ # being the default refcount entry width.
----
+diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039
- hw/block/nvme.c | 4 ++--
+index XXXXXXX..XXXXXXX 100755
-file changed, 2 insertions(+), 2 deletions(-)
+--- a/tests/qemu-iotests/039
++++ b/tests/qemu-iotests/039
-diff --git a/hw/block/nvme.c b/hw/block/nvme.c
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
-index XXXXXXX..XXXXXXX 100644
+ _supported_fmt qcow2
---- a/hw/block/nvme.c
+ _supported_proto file
-+++ b/hw/block/nvme.c
+ _supported_os Linux
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
+-_default_cache_mode "writethrough"
-         result = blk_enable_write_cache(n->conf.blk);
+-_supported_cache_modes "writethrough"
-         break;
++_default_cache_mode writethrough
-     case NVME_NUMBER_OF_QUEUES:
++_supported_cache_modes writethrough
--        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));
+ size=128M
-         break;
-     default:
+diff --git a/tests/qemu-iotests/052 b/tests/qemu-iotests/052
-         return NVME_INVALID_FIELD | NVME_DNR;
+index XXXXXXX..XXXXXXX 100755
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
+--- a/tests/qemu-iotests/052
-         break;
++++ b/tests/qemu-iotests/052
-     case NVME_NUMBER_OF_QUEUES:
+@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
-         req->cqe.result =
+ _supported_proto file
--            cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
-+            cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
+ # Don't do O_DIRECT on tmpfs
-         break;
+-_supported_cache_modes "writeback" "writethrough" "unsafe"
-     default:
++_supported_cache_modes writeback writethrough unsafe
-         return NVME_INVALID_FIELD | NVME_DNR;
  size=128M
  _make_test_img $size
 diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/091
 +++ b/tests/qemu-iotests/091
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto file
  _supported_os Linux
 -_default_cache_mode "none"
 -_supported_cache_modes "writethrough" "none" "writeback"
 +_default_cache_mode none
 +_supported_cache_modes writethrough none writeback
  size=1G
 --
-.13.5
+.21.0

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 54b89db5309d5fa8b5d3fe5fe56f81704e2f9706:

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging (2019-09-03 09:43:26 +0100)

are available in the Git repository at:

https://github.com/XanClic/qemu.git tags/pull-block-2019-09-03

for you to fetch changes up to 755c5fe79d88717600356d3edf04835bba43dcb6:

iotests: Unify cache mode quoting (2019-09-03 14:56:06 +0200)

----------------------------------------------------------------
Block patches:
- qemu-io now accepts a file to read a write pattern from
- Ensure that raw files have their first block allocated so we can probe
  the O_DIRECT alignment if necessary
- Various fixes

----------------------------------------------------------------
v2:
- Added a patch we already had on the list to keep the iotests passing
  when $DISPLAY is not set

----------------------------------------------------------------
Denis Plotnikov (1):
  qemu-io: add pattern file for write command

Max Reitz (8):
  iotests: Fix _filter_img_create()
  vmdk: Use bdrv_dirname() for relative extent paths
  iotests: Keep testing broken relative extent paths
  vmdk: Reject invalid compressed writes
  iotests: Disable broken streamOptimized tests
  iotests: Disable 110 for vmdk.twoGbMaxExtentSparse
  iotests: Disable 126 for flat vmdk subformats
  iotests: Add -display none to the qemu options

Nir Soffer (3):
  block: posix: Always allocate the first block
  iotests: Test allocate_first_block() with O_DIRECT
  iotests: Unify cache mode quoting

Stefan Hajnoczi (1):
  file-posix: fix request_alignment typo

Thomas Huth (2):
  iotests: Check for enabled drivers before testing them
  tests/check-block: Skip iotests when sanitizers are enabled

Vladimir Sementsov-Ogievskiy (1):
  block: fix permission update in bdrv_replace_node

block.c                                       |  5 +-
 block/file-posix.c                            | 53 +++++++++-
 block/vmdk.c                                  | 64 ++++++++----
 qemu-io-cmds.c                                | 99 +++++++++++++++++--
 tests/check-block.sh                          |  5 +
 tests/qemu-iotests/002                        |  1 +
 tests/qemu-iotests/003                        |  1 +
 tests/qemu-iotests/005                        |  3 +-
 tests/qemu-iotests/009                        |  1 +
 tests/qemu-iotests/010                        |  1 +
 tests/qemu-iotests/011                        |  1 +
 tests/qemu-iotests/017                        |  3 +-
 tests/qemu-iotests/018                        |  3 +-
 tests/qemu-iotests/019                        |  3 +-
 tests/qemu-iotests/020                        |  3 +-
 tests/qemu-iotests/026                        |  4 +-
 tests/qemu-iotests/027                        |  1 +
 tests/qemu-iotests/032                        |  1 +
 tests/qemu-iotests/033                        |  1 +
 tests/qemu-iotests/034                        |  3 +-
 tests/qemu-iotests/037                        |  3 +-
 tests/qemu-iotests/039                        |  4 +-
 tests/qemu-iotests/052                        |  2 +-
 tests/qemu-iotests/059                        | 34 ++++++-
 tests/qemu-iotests/059.out                    | 26 +++--
 tests/qemu-iotests/063                        |  3 +-
 tests/qemu-iotests/071                        |  1 +
 tests/qemu-iotests/072                        |  1 +
 tests/qemu-iotests/081                        |  4 +-
 tests/qemu-iotests/091                        |  4 +-
 tests/qemu-iotests/099                        |  1 +
 tests/qemu-iotests/105                        |  3 +-
 tests/qemu-iotests/110                        |  3 +-
 tests/qemu-iotests/120                        |  1 +
 tests/qemu-iotests/126                        |  2 +
 tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
 tests/qemu-iotests/150.out.raw                | 12 +++
 tests/qemu-iotests/162                        |  4 +-
 tests/qemu-iotests/175                        | 47 +++++++--
 tests/qemu-iotests/175.out                    | 16 ++-
 tests/qemu-iotests/178.out.qcow2              |  4 +-
 tests/qemu-iotests/184                        |  1 +
 tests/qemu-iotests/186                        |  1 +
 tests/qemu-iotests/197                        |  1 +
 tests/qemu-iotests/215                        |  1 +
 tests/qemu-iotests/221.out                    | 12 ++-
 tests/qemu-iotests/251                        |  1 +
 tests/qemu-iotests/253.out                    | 12 ++-
 tests/qemu-iotests/check                      |  6 +-
 tests/qemu-iotests/common.filter              |  4 +-
 tests/qemu-iotests/common.rc                  | 14 +++
 51 files changed, 394 insertions(+), 90 deletions(-)
 rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
 create mode 100644 tests/qemu-iotests/150.out.raw

-- 
2.21.0

From: Denis Plotnikov <dplotnikov@virtuozzo.com>

The patch allows to provide a pattern file for write
command. There was no similar ability before.

Signed-off-by: Denis Plotnikov <dplotnikov@virtuozzo.com>
Message-id: 20190820164616.4072-1-dplotnikov@virtuozzo.com
Reviewed-by: Eric Blake <eblake@redhat.com>
[mreitz: Keep optstring in alphabetical order]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qemu-io-cmds.c | 99 +++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 93 insertions(+), 6 deletions(-)

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static void qemu_io_free(void *p)
     qemu_vfree(p);
 }
 
+/*
+ * qemu_io_alloc_from_file()
+ *
+ * Allocates the buffer and populates it with the content of the given file
+ * up to @len bytes. If the file length is less than @len, then the buffer
+ * is populated with the file content cyclically.
+ *
+ * @blk - the block backend where the buffer content is going to be written to
+ * @len - the buffer length
+ * @file_name - the file to read the content from
+ *
+ * Returns: the buffer pointer on success
+ *          NULL on error
+ */
+static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len,
+                                     const char *file_name)
+{
+    char *buf, *buf_origin;
+    FILE *f = fopen(file_name, "r");
+    int pattern_len;
+
+    if (!f) {
+        perror(file_name);
+        return NULL;
+    }
+
+    if (qemuio_misalign) {
+        len += MISALIGN_OFFSET;
+    }
+
+    buf_origin = buf = blk_blockalign(blk, len);
+
+    if (qemuio_misalign) {
+        buf_origin += MISALIGN_OFFSET;
+        buf += MISALIGN_OFFSET;
+        len -= MISALIGN_OFFSET;
+    }
+
+    pattern_len = fread(buf_origin, 1, len, f);
+
+    if (ferror(f)) {
+        perror(file_name);
+        goto error;
+    }
+
+    if (pattern_len == 0) {
+        fprintf(stderr, "%s: file is empty\n", file_name);
+        goto error;
+    }
+
+    fclose(f);
+
+    if (len > pattern_len) {
+        len -= pattern_len;
+        buf += pattern_len;
+
+        while (len > 0) {
+            size_t len_to_copy = MIN(pattern_len, len);
+
+            memcpy(buf, buf_origin, len_to_copy);
+
+            len -= len_to_copy;
+            buf += len_to_copy;
+        }
+    }
+
+    return buf_origin;
+
+error:
+    qemu_io_free(buf_origin);
+    return NULL;
+}
+
 static void dump_buffer(const void *buffer, int64_t offset, int64_t len)
 {
     uint64_t i;
@@ -XXX,XX +XXX,XX @@ static void write_help(void)
 " -n, -- with -z, don't allow slow fallback\n"
 " -p, -- ignored for backwards compatibility\n"
 " -P, -- use different pattern to fill file\n"
+" -s, -- use a pattern file to fill the write buffer\n"
 " -C, -- report statistics in a machine parsable format\n"
 " -q, -- quiet mode, do not show I/O statistics\n"
 " -u, -- with -z, allow unmapping\n"
@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t write_cmd = {
     .perm       = BLK_PERM_WRITE,
     .argmin     = 2,
     .argmax     = -1,
-    .args       = "[-bcCfnquz] [-P pattern] off len",
+    .args       = "[-bcCfnquz] [-P pattern | -s source_file] off len",
     .oneline    = "writes a number of bytes at a specified offset",
     .help       = write_help,
 };
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
 {
     struct timespec t1, t2;
     bool Cflag = false, qflag = false, bflag = false;
-    bool Pflag = false, zflag = false, cflag = false;
+    bool Pflag = false, zflag = false, cflag = false, sflag = false;
     int flags = 0;
     int c, cnt, ret;
     char *buf = NULL;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
     /* Some compilers get confused and warn if this is not initialized.  */
     int64_t total = 0;
     int pattern = 0xcd;
+    const char *file_name = NULL;
 
-    while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {
+    while ((c = getopt(argc, argv, "bcCfnpP:qs:uz")) != -1) {
         switch (c) {
         case 'b':
             bflag = true;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
         case 'q':
             qflag = true;
             break;
+        case 's':
+            sflag = true;
+            file_name = optarg;
+            break;
         case 'u':
             flags |= BDRV_REQ_MAY_UNMAP;
             break;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
         return -EINVAL;
     }
 
-    if (zflag && Pflag) {
-        printf("-z and -P cannot be specified at the same time\n");
+    if (zflag + Pflag + sflag > 1) {
+        printf("Only one of -z, -P, and -s "
+               "can be specified at the same time\n");
         return -EINVAL;
     }
 
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
     }
 
     if (!zflag) {
-        buf = qemu_io_alloc(blk, count, pattern);
+        if (sflag) {
+            buf = qemu_io_alloc_from_file(blk, count, file_name);
+            if (!buf) {
+                return -EINVAL;
+            }
+        } else {
+            buf = qemu_io_alloc(blk, count, pattern);
+        }
     }
 
     clock_gettime(CLOCK_MONOTONIC, &t1);
-- 
2.21.0

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

It's wrong to OR shared permissions. It may lead to crash on further
permission updates.
Also, no needs to consider previously calculated permissions, as at
this point we already bind all new parents and bdrv_get_cumulative_perm
result is enough. So fix the bug by just set permissions by
bdrv_get_cumulative_perm result.

Bug was introduced in long ago 234ac1a9025, in 2.9.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-id: 20190824100740.61635-1-vsementsov@virtuozzo.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
 {
     BdrvChild *c, *next;
     GSList *list = NULL, *p;
-    uint64_t old_perm, old_shared;
     uint64_t perm = 0, shared = BLK_PERM_ALL;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
         bdrv_unref(from);
     }
 
-    bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
-    bdrv_set_perm(to, old_perm | perm, old_shared | shared);
+    bdrv_get_cumulative_perm(to, &perm, &shared);
+    bdrv_set_perm(to, perm, shared);
 
 out:
     g_slist_free(list);
-- 
2.21.0

From: Nir Soffer <nirsof@gmail.com>

When creating an image with preallocation "off" or "falloc", the first
block of the image is typically not allocated. When using Gluster
storage backed by XFS filesystem, reading this block using direct I/O
succeeds regardless of request length, fooling alignment detection.

In this case we fallback to a safe value (4096) instead of the optimal
value (512), which may lead to unneeded data copying when aligning
requests.  Allocating the first block avoids the fallback.

Since we allocate the first block even with preallocation=off, we no
longer create images with zero disk size:

$ ./qemu-img create -f raw test.raw 1g
    Formatting 'test.raw', fmt=raw size=1073741824

$ ls -lhs test.raw
    4.0K -rw-r--r--. 1 nsoffer nsoffer 1.0G Aug 16 23:48 test.raw

And converting the image requires additional cluster:

$ ./qemu-img measure -f raw -O qcow2 test.raw
    required size: 458752
    fully allocated size: 1074135040

When using format like vmdk with multiple files per image, we allocate
one block per file:

$ ./qemu-img create -f vmdk -o subformat=twoGbMaxExtentFlat test.vmdk 4g
    Formatting 'test.vmdk', fmt=vmdk size=4294967296 compat6=off hwversion=undefined subformat=twoGbMaxExtentFlat

$ ls -lhs test*.vmdk
    4.0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f001.vmdk
    4.0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f002.vmdk
    4.0K -rw-r--r--. 1 nsoffer nsoffer  353 Aug 27 03:23 test.vmdk

I did quick performance test for copying disks with qemu-img convert to
new raw target image to Gluster storage with sector size of 512 bytes:

for i in $(seq 10); do
        rm -f dst.raw
        sleep 10
        time ./qemu-img convert -f raw -O raw -t none -T none src.raw dst.raw
    done

Here is a table comparing the total time spent:

Type    Before(s)   After(s)    Diff(%)
---------------------------------------
real      530.028    469.123      -11.4
user       17.204     10.768      -37.4
sys        17.881      7.011      -60.7

We can see very clear improvement in CPU usage.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>
Message-id: 20190827010528.8818-2-nsoffer@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/file-posix.c                            | 51 +++++++++++++++++++
 tests/qemu-iotests/059.out                    |  2 +-
 tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
 tests/qemu-iotests/150.out.raw                | 12 +++++
 tests/qemu-iotests/175                        | 19 ++++---
 tests/qemu-iotests/175.out                    |  8 +--
 tests/qemu-iotests/178.out.qcow2              |  4 +-
 tests/qemu-iotests/221.out                    | 12 +++--
 tests/qemu-iotests/253.out                    | 12 +++--
 9 files changed, 99 insertions(+), 21 deletions(-)
 rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
 create mode 100644 tests/qemu-iotests/150.out.raw

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
     return ret;
 }
 
+/*
+ * Help alignment probing by allocating the first block.
+ *
+ * When reading with direct I/O from unallocated area on Gluster backed by XFS,
+ * reading succeeds regardless of request length. In this case we fallback to
+ * safe alignment which is not optimal. Allocating the first block avoids this
+ * fallback.
+ *
+ * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
+ * request alignment, so we use safe values.
+ *
+ * Returns: 0 on success, -errno on failure. Since this is an optimization,
+ * caller may ignore failures.
+ */
+static int allocate_first_block(int fd, size_t max_size)
+{
+    size_t write_size = (max_size < MAX_BLOCKSIZE)
+        ? BDRV_SECTOR_SIZE
+        : MAX_BLOCKSIZE;
+    size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
+    void *buf;
+    ssize_t n;
+    int ret;
+
+    buf = qemu_memalign(max_align, write_size);
+    memset(buf, 0, write_size);
+
+    do {
+        n = pwrite(fd, buf, write_size, 0);
+    } while (n == -1 && errno == EINTR);
+
+    ret = (n == -1) ? -errno : 0;
+
+    qemu_vfree(buf);
+    return ret;
+}
+
 static int handle_aiocb_truncate(void *opaque)
 {
     RawPosixAIOData *aiocb = opaque;
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
                 /* posix_fallocate() doesn't set errno. */
                 error_setg_errno(errp, -result,
                                  "Could not preallocate new data");
+            } else if (current_length == 0) {
+                /*
+                 * posix_fallocate() uses fallocate() if the filesystem
+                 * supports it, or fallback to manually writing zeroes. If
+                 * fallocate() was used, unaligned reads from the fallocated
+                 * area in raw_probe_alignment() will succeed, hence we need to
+                 * allocate the first block.
+                 *
+                 * Optimize future alignment probing; ignore failures.
+                 */
+                allocate_first_block(fd, offset);
             }
         } else {
             result = 0;
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
         if (ftruncate(fd, offset) != 0) {
             result = -errno;
             error_setg_errno(errp, -result, "Could not resize file");
+        } else if (current_length == 0 && offset > current_length) {
+            /* Optimize future alignment probing; ignore failures. */
+            allocate_first_block(fd, offset);
         }
         return result;
     default:
diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMax
 image: TEST_DIR/t.vmdk
 file format: vmdk
 virtual size: 0.977 TiB (1073741824000 bytes)
-disk size: 16 KiB
+disk size: 1.97 MiB
 Format specific information:
     cid: XXXXXXXX
     parent cid: XXXXXXXX
diff --git a/tests/qemu-iotests/150.out b/tests/qemu-iotests/150.out.qcow2
similarity index 100%
rename from tests/qemu-iotests/150.out
rename to tests/qemu-iotests/150.out.qcow2
diff --git a/tests/qemu-iotests/150.out.raw b/tests/qemu-iotests/150.out.raw
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/150.out.raw
@@ -XXX,XX +XXX,XX @@
+QA output created by 150
+
+=== Mapping sparse conversion ===
+
+Offset          Length          File
+0               0x1000          TEST_DIR/t.IMGFMT
+
+=== Mapping non-sparse conversion ===
+
+Offset          Length          File
+0               0x100000        TEST_DIR/t.IMGFMT
+*** done
diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/175
+++ b/tests/qemu-iotests/175
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # the file size.  This function hides the resulting difference in the
 # stat -c '%b' output.
 # Parameter 1: Number of blocks an empty file occupies
-# Parameter 2: Image size in bytes
+# Parameter 2: Minimal number of blocks in an image
+# Parameter 3: Image size in bytes
 _filter_blocks()
 {
     extra_blocks=$1
-    img_size=$2
+    min_blocks=$2
+    img_size=$3
 
-    sed -e "s/blocks=$extra_blocks\$\$\\|[^0-9]\$/nothing allocated/" \
-        -e "s/blocks=$((extra_blocks + img_size / 512))\$\$\\|[^0-9]\$/everything allocated/"
+    sed -e "s/blocks=$min_blocks\$\$\\|[^0-9]\$/min allocation/" \
+        -e "s/blocks=$((extra_blocks + img_size / 512))\$\$\\|[^0-9]\$/max allocation/"
 }
 
 # get standard environment, filters and checks
@@ -XXX,XX +XXX,XX @@ size=$((1 * 1024 * 1024))
 touch "$TEST_DIR/empty"
 extra_blocks=$(stat -c '%b' "$TEST_DIR/empty")
 
+# We always write the first byte; check how many blocks this filesystem
+# allocates to match empty image alloation.
+printf "\0" > "$TEST_DIR/empty"
+min_blocks=$(stat -c '%b' "$TEST_DIR/empty")
+
 echo
 echo "== creating image with default preallocation =="
 _make_test_img $size | _filter_imgfmt
-stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
+stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
 
 for mode in off full falloc; do
     echo
     echo "== creating image with preallocation $mode =="
     IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt
-    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
+    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
 done
 
 # success, all done
diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/175.out
+++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@ QA output created by 175
 
 == creating image with default preallocation ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576
-size=1048576, nothing allocated
+size=1048576, min allocation
 
 == creating image with preallocation off ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off
-size=1048576, nothing allocated
+size=1048576, min allocation
 
 == creating image with preallocation full ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full
-size=1048576, everything allocated
+size=1048576, max allocation
 
 == creating image with preallocation falloc ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
-size=1048576, everything allocated
+size=1048576, max allocation
  *** done
diff --git a/tests/qemu-iotests/178.out.qcow2 b/tests/qemu-iotests/178.out.qcow2
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/178.out.qcow2
+++ b/tests/qemu-iotests/178.out.qcow2
@@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608
 == raw input image with data (human) ==
 
 Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
-required size: 393216
+required size: 458752
 fully allocated size: 1074135040
 wrote 512/512 bytes at offset 512
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608
 
 Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
 {
-    "required": 393216,
+    "required": 458752,
     "fully-allocated": 1074135040
 }
 wrote 512/512 bytes at offset 512
diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/221.out
+++ b/tests/qemu-iotests/221.out
@@ -XXX,XX +XXX,XX @@ QA output created by 221
 === Check mapping of unaligned raw image ===
 
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65537
-[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 wrote 1/1 bytes at offset 65536
 1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 *** done
diff --git a/tests/qemu-iotests/253.out b/tests/qemu-iotests/253.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/253.out
+++ b/tests/qemu-iotests/253.out
@@ -XXX,XX +XXX,XX @@ QA output created by 253
 === Check mapping of unaligned raw image ===
 
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048575
-[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 wrote 65535/65535 bytes at offset 983040
 63.999 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
-[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
 *** done
-- 
2.21.0

From: Nir Soffer <nirsof@gmail.com>

Using block_resize we can test allocate_first_block() with file
descriptor opened with O_DIRECT, ensuring that it works for any size
larger than 4096 bytes.

Testing smaller sizes is tricky as the result depends on the filesystem
used for testing. For example on NFS any size will work since O_DIRECT
does not require any alignment.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190827010528.8818-3-nsoffer@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/175     | 28 ++++++++++++++++++++++++++++
 tests/qemu-iotests/175.out |  8 ++++++++
 2 files changed, 36 insertions(+)

diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/175
+++ b/tests/qemu-iotests/175
@@ -XXX,XX +XXX,XX @@ _filter_blocks()
         -e "s/blocks=$((extra_blocks + img_size / 512))\$\$\\|[^0-9]\$/max allocation/"
 }
 
+# Resize image using block_resize.
+# Parameter 1: image path
+# Parameter 2: new size
+_block_resize()
+{
+    local path=$1
+    local size=$2
+
+    $QEMU -qmp stdio -nographic -nodefaults \
+        -blockdev file,node-name=file,filename=$path,cache.direct=on \
+        <<EOF
+{'execute': 'qmp_capabilities'}
+{'execute': 'block_resize', 'arguments': {'node-name': 'file', 'size': $size}}
+{'execute': 'quit'}
+EOF
+}
+
 # get standard environment, filters and checks
 . ./common.rc
 . ./common.filter
@@ -XXX,XX +XXX,XX @@ _supported_fmt raw
 _supported_proto file
 _supported_os Linux
 
+_default_cache_mode none
+_supported_cache_modes none directsync
+
 size=$((1 * 1024 * 1024))
 
 touch "$TEST_DIR/empty"
@@ -XXX,XX +XXX,XX @@ for mode in off full falloc; do
     stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
 done
 
+for new_size in 4096 1048576; do
+    echo
+    echo "== resize empty image with block_resize =="
+    _make_test_img 0 | _filter_imgfmt
+    _block_resize $TEST_IMG $new_size >/dev/null
+    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $new_size
+done
+
 # success, all done
 echo "*** done"
 rm -f $seq.full
diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/175.out
+++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@ size=1048576, max allocation
 == creating image with preallocation falloc ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
 size=1048576, max allocation
+
+== resize empty image with block_resize ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
+size=4096, min allocation
+
+== resize empty image with block_resize ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
+size=1048576, min allocation
  *** done
-- 
2.21.0

fe646693acc changed qemu-img create's output so that it no longer prints
single quotes around parameter values.  The subformat and adapter_type
filters in _filter_img_create() have never been adapted to that change.

Fixes: fe646693acc13ac48b98435d14149ab04dc597bc
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-2-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/059.out       | 16 ++++++++--------
 tests/qemu-iotests/common.filter |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 qemu-io: can't open device TEST_DIR/t.vmdk: L1 size too big
 
 === Testing monolithicFlat creation and opening ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
 image: TEST_DIR/t.IMGFMT
 file format: IMGFMT
 virtual size: 2 GiB (2147483648 bytes)
 
 === Testing monolithicFlat with zeroed_grain ===
 qemu-img: TEST_DIR/t.IMGFMT: Flat image can't enable zeroed grain
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
 
 === Testing big twoGbMaxExtentFlat ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMaxExtentFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000
 image: TEST_DIR/t.vmdk
 file format: vmdk
 virtual size: 0.977 TiB (1073741824000 bytes)
@@ -XXX,XX +XXX,XX @@ Format specific information:
 qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Invalid extent line: RW 12582912 VMFS "dummy.IMGFMT" 1
 
 === Testing truncated sparse ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400 subformat=monolithicSparse
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400
 qemu-img: Could not open 'TEST_DIR/t.IMGFMT': File truncated, expecting at least 13172736 bytes
 
 === Converting to streamOptimized from image with small cluster size===
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing monolithicFlat with internally generated JSON file name ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
 
 === Testing version 3 ===
@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 64931328
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing 4TB monolithicFlat creation and IO ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104
 image: TEST_DIR/t.IMGFMT
 file format: IMGFMT
 virtual size: 4 TiB (4398046511104 bytes)
@@ -XXX,XX +XXX,XX @@ read 1024/1024 bytes at offset 966367641600
 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing qemu-img map on extents ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=monolithicSparse
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
 wrote 1024/1024 bytes at offset 65024
 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 wrote 1024/1024 bytes at offset 2147483136
@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
 0               0x20000         0x3f0000        TEST_DIR/t.vmdk
 0x7fff0000      0x20000         0x410000        TEST_DIR/t.vmdk
 0x140000000     0x10000         0x430000        TEST_DIR/t.vmdk
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=twoGbMaxExtentSparse
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
 wrote 1024/1024 bytes at offset 65024
 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 wrote 1024/1024 bytes at offset 2147483136
diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.filter
+++ b/tests/qemu-iotests/common.filter
@@ -XXX,XX +XXX,XX @@ _filter_img_create()
         -e "s# compat6=\$on\\|off\$##g" \
         -e "s# static=\$on\\|off\$##g" \
         -e "s# zeroed_grain=\$on\\|off\$##g" \
-        -e "s# subformat='[^']*'##g" \
-        -e "s# adapter_type='[^']*'##g" \
+        -e "s# subformat=[^ ]*##g" \
+        -e "s# adapter_type=[^ ]*##g" \
         -e "s# hwversion=[^ ]*##g" \
         -e "s# lazy_refcounts=\$on\\|off\$##g" \
         -e "s# block_size=[0-9]\\+##g" \
-- 
2.21.0

This makes iotest 033 pass with e.g. subformat=monolithicFlat.  It also
turns a former error in 059 into success.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190815153638.4600-3-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vmdk.c               | 54 ++++++++++++++++++++++++--------------
 tests/qemu-iotests/059     |  7 +++--
 tests/qemu-iotests/059.out |  4 ++-
 3 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static const char *next_line(const char *s)
 }
 
 static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
-                              const char *desc_file_path, QDict *options,
-                              Error **errp)
+                              QDict *options, Error **errp)
 {
     int ret;
     int matches;
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
     const char *p, *np;
     int64_t sectors = 0;
     int64_t flat_offset;
+    char *desc_file_dir = NULL;
     char *extent_path;
     BdrvChild *extent_file;
     BDRVVmdkState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
             continue;
         }
 
-        if (!path_is_absolute(fname) && !path_has_protocol(fname) &&
-            !desc_file_path[0])
-        {
-            bdrv_refresh_filename(bs->file->bs);
-            error_setg(errp, "Cannot use relative extent paths with VMDK "
-                       "descriptor file '%s'", bs->file->bs->filename);
-            return -EINVAL;
-        }
+        if (path_is_absolute(fname)) {
+            extent_path = g_strdup(fname);
+        } else {
+            if (!desc_file_dir) {
+                desc_file_dir = bdrv_dirname(bs->file->bs, errp);
+                if (!desc_file_dir) {
+                    bdrv_refresh_filename(bs->file->bs);
+                    error_prepend(errp, "Cannot use relative paths with VMDK "
+                                  "descriptor file '%s': ",
+                                  bs->file->bs->filename);
+                    ret = -EINVAL;
+                    goto out;
+                }
+            }
 
-        extent_path = path_combine(desc_file_path, fname);
+            extent_path = g_strconcat(desc_file_dir, fname, NULL);
+        }
 
         ret = snprintf(extent_opt_prefix, 32, "extents.%d", s->num_extents);
         assert(ret < 32);
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
         g_free(extent_path);
         if (local_err) {
             error_propagate(errp, local_err);
-            return -EINVAL;
+            ret = -EINVAL;
+            goto out;
         }
 
         /* save to extents array */
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
                             0, 0, 0, 0, 0, &extent, errp);
             if (ret < 0) {
                 bdrv_unref_child(bs, extent_file);
-                return ret;
+                goto out;
             }
             extent->flat_start_offset = flat_offset << 9;
         } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
             g_free(buf);
             if (ret) {
                 bdrv_unref_child(bs, extent_file);
-                return ret;
+                goto out;
             }
             extent = &s->extents[s->num_extents - 1];
         } else if (!strcmp(type, "SESPARSE")) {
             ret = vmdk_open_se_sparse(bs, extent_file, bs->open_flags, errp);
             if (ret) {
                 bdrv_unref_child(bs, extent_file);
-                return ret;
+                goto out;
             }
             extent = &s->extents[s->num_extents - 1];
         } else {
             error_setg(errp, "Unsupported extent type '%s'", type);
             bdrv_unref_child(bs, extent_file);
-            return -ENOTSUP;
+            ret = -ENOTSUP;
+            goto out;
         }
         extent->type = g_strdup(type);
     }
-    return 0;
+
+    ret = 0;
+    goto out;
 
 invalid:
     np = next_line(p);
@@ -XXX,XX +XXX,XX @@ invalid:
         np--;
     }
     error_setg(errp, "Invalid extent line: %.*s", (int)(np - p), p);
-    return -EINVAL;
+    ret = -EINVAL;
+
+out:
+    g_free(desc_file_dir);
+    return ret;
 }
 
 static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
     }
     s->create_type = g_strdup(ct);
     s->desc_offset = 0;
-    ret = vmdk_parse_extents(buf, bs, bs->file->bs->exact_filename, options,
-                             errp);
+    ret = vmdk_parse_extents(buf, bs, options, errp);
 exit:
     return ret;
 }
diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/059
+++ b/tests/qemu-iotests/059
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
 
 echo
 echo "=== Testing monolithicFlat with internally generated JSON file name ==="
+# Should work, because bdrv_dirname() works fine with blkdebug
 IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
-$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" 2>&1 \
-    | _filter_testdir | _filter_imgfmt
+$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
+         -c info \
+    2>&1 \
+    | _filter_testdir | _filter_imgfmt | _filter_img_info
 _cleanup_test_img
 
 echo
diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
 
 === Testing monolithicFlat with internally generated JSON file name ===
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
-qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
+format name: IMGFMT
+cluster size: 0 bytes
+vm state offset: 0 bytes
 
 === Testing version 3 ===
 image: TEST_DIR/iotest-version3.IMGFMT
-- 
2.21.0

We had a test for a case where relative extent paths did not work, but
unfortunately we just fixed the underlying problem, so it works now.
This patch adds a new test case that still fails.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-4-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/059     | 27 +++++++++++++++++++++++++++
 tests/qemu-iotests/059.out |  4 ++++
 2 files changed, 31 insertions(+)

diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/059
+++ b/tests/qemu-iotests/059
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
 
 echo
 echo "=== Testing monolithicFlat with internally generated JSON file name ==="
+
+echo '--- blkdebug ---'
 # Should work, because bdrv_dirname() works fine with blkdebug
 IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
 $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TE
     | _filter_testdir | _filter_imgfmt | _filter_img_info
 _cleanup_test_img
 
+echo '--- quorum ---'
+# Should not work, because bdrv_dirname() does not work with quorum
+IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
+cp "$TEST_IMG" "$TEST_IMG.orig"
+
+filename="json:{
+    \"driver\": \"$IMGFMT\",
+    \"file\": {
+        \"driver\": \"quorum\",
+        \"children\": [ {
+            \"driver\": \"file\",
+            \"filename\": \"$TEST_IMG\"
+        }, {
+            \"driver\": \"file\",
+            \"filename\": \"$TEST_IMG.orig\"
+        } ],
+        \"vote-threshold\": 1
+    } }"
+
+filename=$(echo "$filename" | tr '\n' ' ' | sed -e 's/\s\+/ /g')
+$QEMU_IMG info "$filename" 2>&1 \
+    | sed -e "s/'json:[^']*'/\$QUORUM_FILE/g" \
+    | _filter_testdir | _filter_imgfmt | _filter_img_info
+
+
 echo
 echo "=== Testing version 3 ==="
 _use_sample_img iotest-version3.vmdk.bz2
diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing monolithicFlat with internally generated JSON file name ===
+--- blkdebug ---
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 format name: IMGFMT
 cluster size: 0 bytes
 vm state offset: 0 bytes
+--- quorum ---
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
+qemu-img: Could not open $QUORUM_FILE: Cannot use relative paths with VMDK descriptor file $QUORUM_FILE: Cannot generate a base directory for quorum nodes
 
 === Testing version 3 ===
 image: TEST_DIR/iotest-version3.IMGFMT
-- 
2.21.0

Compressed writes generally have to write full clusters, not just in
theory but also in practice when it comes to vmdk's streamOptimized
subformat.  It currently is just silently broken for writes with
non-zero in-cluster offsets:

$ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
$ qemu-io -c 'write 4k 4k' -c 'read 4k 4k' foo.vmdk
wrote 4096/4096 bytes at offset 4096
4 KiB, 1 ops; 00.01 sec (443.724 KiB/sec and 110.9309 ops/sec)
read failed: Invalid argument

(The technical reason is that vmdk_write_extent() just writes the
incomplete compressed data actually to offset 4k.  When reading the
data, vmdk_read_extent() looks at offset 0 and finds the compressed data
size to be 0, because that is what it reads from there.  This yields an
error.)

For incomplete writes with zero in-cluster offsets, the error path when
reading the rest of the cluster is a bit different, but the result is
the same:

$ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
$ qemu-io -c 'write 0k 4k' -c 'read 4k 4k' foo.vmdk
wrote 4096/4096 bytes at offset 0
4 KiB, 1 ops; 00.01 sec (362.641 KiB/sec and 90.6603 ops/sec)
read failed: Invalid argument

(Here, vmdk_read_extent() finds the data and then sees that the
uncompressed data is short.)

It is better to reject invalid writes than to make the user believe they
might have succeeded and then fail when trying to read it back.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-5-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vmdk.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
     if (extent->compressed) {
         void *compressed_data;
 
+        /* Only whole clusters */
+        if (offset_in_cluster ||
+            n_bytes > (extent->cluster_sectors * SECTOR_SIZE) ||
+            (n_bytes < (extent->cluster_sectors * SECTOR_SIZE) &&
+             offset + n_bytes != extent->end_sector * SECTOR_SIZE))
+        {
+            ret = -EINVAL;
+            goto out;
+        }
+
         if (!extent->has_marker) {
             ret = -EINVAL;
             goto out;
-- 
2.21.0

streamOptimized does not support writes that do not span exactly one
cluster.  Furthermore, it cannot rewrite already allocated clusters.
As such, many iotests do not work with it.  Disable them.

diff --git a/tests/qemu-iotests/002 b/tests/qemu-iotests/002
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/002
+++ b/tests/qemu-iotests/002
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=128M
diff --git a/tests/qemu-iotests/003 b/tests/qemu-iotests/003
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/003
+++ b/tests/qemu-iotests/003
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 size=128M
 offset=67M
diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/005
+++ b/tests/qemu-iotests/005
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto generic
 _supported_os Linux
 _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 # vpc is limited to 127GB, so we can't test it here
 if [ "$IMGFMT" = "vpc" ]; then
diff --git a/tests/qemu-iotests/009 b/tests/qemu-iotests/009
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/009
+++ b/tests/qemu-iotests/009
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=6G
diff --git a/tests/qemu-iotests/010 b/tests/qemu-iotests/010
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/010
+++ b/tests/qemu-iotests/010
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=6G
diff --git a/tests/qemu-iotests/011 b/tests/qemu-iotests/011
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/011
+++ b/tests/qemu-iotests/011
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=6G
diff --git a/tests/qemu-iotests/017 b/tests/qemu-iotests/017
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/017
+++ b/tests/qemu-iotests/017
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto generic
 _unsupported_proto vxhs
-_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
+                     "subformat=streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 
diff --git a/tests/qemu-iotests/018 b/tests/qemu-iotests/018
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/018
+++ b/tests/qemu-iotests/018
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto file
 _supported_os Linux
-_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
+                     "streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 
diff --git a/tests/qemu-iotests/019 b/tests/qemu-iotests/019
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/019
+++ b/tests/qemu-iotests/019
@@ -XXX,XX +XXX,XX @@ _supported_proto file
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 CLUSTER_SIZE=65536
diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/020
+++ b/tests/qemu-iotests/020
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed
 _supported_proto file
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 
diff --git a/tests/qemu-iotests/027 b/tests/qemu-iotests/027
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/027
+++ b/tests/qemu-iotests/027
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt vmdk qcow qcow2 qed
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=128M
diff --git a/tests/qemu-iotests/032 b/tests/qemu-iotests/032
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/032
+++ b/tests/qemu-iotests/032
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # This works for any image format (though unlikely to segfault for raw)
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 echo
 echo === Prepare image ===
diff --git a/tests/qemu-iotests/033 b/tests/qemu-iotests/033
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/033
+++ b/tests/qemu-iotests/033
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=128M
diff --git a/tests/qemu-iotests/034 b/tests/qemu-iotests/034
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/034
+++ b/tests/qemu-iotests/034
@@ -XXX,XX +XXX,XX @@ _supported_proto file
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 CLUSTER_SIZE=4k
 size=128M
diff --git a/tests/qemu-iotests/037 b/tests/qemu-iotests/037
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/037
+++ b/tests/qemu-iotests/037
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed
 _supported_proto file
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 CLUSTER_SIZE=4k
 size=128M
diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/063
+++ b/tests/qemu-iotests/063
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed raw
 _supported_proto file
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 _make_test_img 4M
 
diff --git a/tests/qemu-iotests/072 b/tests/qemu-iotests/072
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/072
+++ b/tests/qemu-iotests/072
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt vpc vmdk vhdx vdi qed qcow2 qcow
 _supported_proto file
+_unsupported_imgopts "subformat=streamOptimized"
 
 IMG_SIZE=64M
 
diff --git a/tests/qemu-iotests/105 b/tests/qemu-iotests/105
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/105
+++ b/tests/qemu-iotests/105
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2 vmdk vhdx qed
 _supported_proto generic
 _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 echo
 echo "creating large image"
diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/197
+++ b/tests/qemu-iotests/197
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto generic
 # LUKS support may be possible, but it complicates things.
 _unsupported_fmt luks
+_unsupported_imgopts "subformat=streamOptimized"
 
 echo
 echo '=== Copy-on-read ==='
diff --git a/tests/qemu-iotests/215 b/tests/qemu-iotests/215
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/215
+++ b/tests/qemu-iotests/215
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto generic
 # LUKS support may be possible, but it complicates things.
 _unsupported_fmt luks
+_unsupported_imgopts "subformat=streamOptimized"
 
 echo
 echo '=== Copy-on-read ==='
diff --git a/tests/qemu-iotests/251 b/tests/qemu-iotests/251
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/251
+++ b/tests/qemu-iotests/251
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt generic
 _supported_proto file
 _supported_os Linux
+_unsupported_imgopts "subformat=streamOptimized"
 
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
     # We use json:{} filenames here, so we cannot work with additional options.
-- 
2.21.0

The error message for the test case where we have a quorum node for
which no directory name can be generated is different: For
twoGbMaxExtentSparse, it complains that it cannot open the extent file.
For other (sub)formats, it just notes that it cannot determine the
backing file path.  Both are fine, but just disable twoGbMaxExtentSparse
for simplicity's sake.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-7-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/110 | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/110 b/tests/qemu-iotests/110
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/110
+++ b/tests/qemu-iotests/110
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Any format supporting backing files
 _supported_fmt qed qcow qcow2 vmdk
 _supported_proto file
-_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
+                     "subformat=twoGbMaxExtentSparse"
 
 TEST_IMG_REL=$(basename "$TEST_IMG")
 
-- 
2.21.0

From: Stefan Hajnoczi <stefanha@redhat.com>

Fixes: a6b257a08e3d72219f03e461a52152672fec0612
       ("file-posix: Handle undetectable alignment")
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190827101328.4062-1-stefanha@redhat.com
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/file-posix.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
         for (i = 0; i < ARRAY_SIZE(alignments); i++) {
             align = alignments[i];
             if (raw_is_io_aligned(fd, buf + align, max_align)) {
-                /* Fallback to request_aligment. */
+                /* Fallback to request_alignment. */
                 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
                 break;
             }
-- 
2.21.0

Without this argument, qemu will print an angry message about not being
able to connect to a display server if $DISPLAY is not set.  For me,
that breaks iotests.supported_formats() because it thus only sees
["Could", "not", "connect"] as the supported formats.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20190819201851.24418-2-mreitz@redhat.com
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/check | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/check
+++ b/tests/qemu-iotests/check
@@ -XXX,XX +XXX,XX @@ export QEMU_PROG="$(type -p "$QEMU_PROG")"
 
 case "$QEMU_PROG" in
     *qemu-system-arm|*qemu-system-aarch64)
-        export QEMU_OPTIONS="-nodefaults -machine virt,accel=qtest"
+        export QEMU_OPTIONS="-nodefaults -display none -machine virt,accel=qtest"
         ;;
     *qemu-system-tricore)
-        export QEMU_OPTIONS="-nodefaults -machine tricore_testboard,accel=qtest"
+        export QEMU_OPTIONS="-nodefaults -display none -machine tricore_testboard,accel=qtest"
         ;;
     *)
-        export QEMU_OPTIONS="-nodefaults -machine accel=qtest"
+        export QEMU_OPTIONS="-nodefaults -display none -machine accel=qtest"
         ;;
 esac
 
-- 
2.21.0

From: Thomas Huth <thuth@redhat.com>

It is possible to enable only a subset of the block drivers with the
"--block-drv-rw-whitelist" option of the "configure" script. All other
drivers are marked as unusable (or only included as read-only with the
"--block-drv-ro-whitelist" option). If an iotest is now using such a
disabled block driver, it is failing - which is bad, since at least the
tests in the "auto" group should be able to deal with this situation.
Thus let's introduce a "_require_drivers" function that can be used by
the shell tests to check for the availability of certain drivers first,
and marks the test as "not run" if one of the drivers is missing.

This patch mainly targets the test in the "auto" group which should
never fail in such a case, but also improves some of the other tests
along the way. Note that we also assume that the "qcow2" and "file"
drivers are always available - otherwise it does not make sense to
run "make check-block" at all (which only tests with qcow2 by default).

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-id: 20190823133552.11680-1-thuth@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/071       |  1 +
 tests/qemu-iotests/081       |  4 +---
 tests/qemu-iotests/099       |  1 +
 tests/qemu-iotests/120       |  1 +
 tests/qemu-iotests/162       |  4 +---
 tests/qemu-iotests/184       |  1 +
 tests/qemu-iotests/186       |  1 +
 tests/qemu-iotests/common.rc | 14 ++++++++++++++
 8 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/071
+++ b/tests/qemu-iotests/071
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto file
+_require_drivers blkdebug blkverify
 
 do_run_qemu()
 {
diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/081
+++ b/tests/qemu-iotests/081
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt raw
 _supported_proto file
 _supported_os Linux
+_require_drivers quorum
 
 do_run_qemu()
 {
@@ -XXX,XX +XXX,XX @@ run_qemu()
                           | _filter_qemu_io | _filter_generated_node_ids
 }
 
-test_quorum=$($QEMU_IMG --help|grep quorum)
-[ "$test_quorum" = "" ] && _supported_fmt quorum
-
 quorum="driver=raw,file.driver=quorum,file.vote-threshold=2"
 quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
 quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
diff --git a/tests/qemu-iotests/099 b/tests/qemu-iotests/099
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/099
+++ b/tests/qemu-iotests/099
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow qcow2 qed vdi vhdx vmdk vpc
 _supported_proto file
 _supported_os Linux
+_require_drivers blkdebug blkverify
 _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
     "subformat=twoGbMaxExtentSparse"
 
diff --git a/tests/qemu-iotests/120 b/tests/qemu-iotests/120
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/120
+++ b/tests/qemu-iotests/120
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt generic
 _supported_proto file
 _unsupported_fmt luks
+_require_drivers raw
 
 _make_test_img 64M
 
diff --git a/tests/qemu-iotests/162 b/tests/qemu-iotests/162
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/162
+++ b/tests/qemu-iotests/162
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt generic
-
-test_ssh=$($QEMU_IMG --help | grep '^Supported formats:.* ssh$ \|$$')
-[ "$test_ssh" = "" ] && _notrun "ssh support required"
+_require_drivers ssh
 
 echo
 echo '=== NBD ==='
diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/184
+++ b/tests/qemu-iotests/184
@@ -XXX,XX +XXX,XX @@ trap "exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_os Linux
+_require_drivers throttle
 
 do_run_qemu()
 {
diff --git a/tests/qemu-iotests/186 b/tests/qemu-iotests/186
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/186
+++ b/tests/qemu-iotests/186
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto file
+_require_drivers null-co
 
 if [ "$QEMU_DEFAULT_MACHINE" != "pc" ]; then
     _notrun "Requires a PC machine"
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _require_command()
     [ -x "$c" ] || _notrun "$1 utility required, skipped this test"
 }
 
+# Check that a set of drivers has been whitelisted in the QEMU binary
+#
+_require_drivers()
+{
+    available=$($QEMU -drive format=help | \
+                sed -e '/Supported formats:/!d' -e 's/Supported formats://')
+    for driver
+    do
+        if ! echo "$available" | grep -q " $driver$ \|$$"; then
+            _notrun "$driver not available"
+        fi
+    done
+}
+
 # make sure this script returns success
 true
-- 
2.21.0

From: Thomas Huth <thuth@redhat.com>

The sanitizers (especially the address sanitizer from Clang) are
sometimes printing out warnings or false positives - this spoils
the output of the iotests, causing some of the tests to fail.
Thus let's skip the automatic iotests during "make check" when the
user configured QEMU with --enable-sanitizers.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-id: 20190823084203.29734-1-thuth@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/check-block.sh | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/check-block.sh b/tests/check-block.sh
index XXXXXXX..XXXXXXX 100755
--- a/tests/check-block.sh
+++ b/tests/check-block.sh
@@ -XXX,XX +XXX,XX @@ if grep -q "TARGET_GPROF=y" *-softmmu/config-target.mak 2>/dev/null ; then
     exit 0
 fi
 
+if grep -q "CFLAGS.*-fsanitize" config-host.mak 2>/dev/null ; then
+    echo "Sanitizers are enabled ==> Not running the qemu-iotests."
+    exit 0
+fi
+
 if [ -z "$(find . -name 'qemu-system-*' -print)" ]; then
     echo "No qemu-system binary available ==> Not running the qemu-iotests."
     exit 0
-- 
2.21.0

From: Nir Soffer <nirsof@gmail.com>

Quoting cache mode is not needed, and most tests use unquoted values.
Unify all test to use the same style.

Message-id: 20190827173432.7656-1-nsoffer@redhat.com
Signed-off-by: Nir Soffer <nsoffer@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/026 | 4 ++--
 tests/qemu-iotests/039 | 4 ++--
 tests/qemu-iotests/052 | 2 +-
 tests/qemu-iotests/091 | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/026
+++ b/tests/qemu-iotests/026
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Currently only qcow2 supports rebasing
 _supported_fmt qcow2
 _supported_proto file
-_default_cache_mode "writethrough"
-_supported_cache_modes "writethrough" "none"
+_default_cache_mode writethrough
+_supported_cache_modes writethrough none
 # The refcount table tests expect a certain minimum width for refcount entries
 # (so that the refcount table actually needs to grow); that minimum is 16 bits,
 # being the default refcount entry width.
diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/039
+++ b/tests/qemu-iotests/039
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
-_default_cache_mode "writethrough"
-_supported_cache_modes "writethrough"
+_default_cache_mode writethrough
+_supported_cache_modes writethrough
 
 size=128M
 
diff --git a/tests/qemu-iotests/052 b/tests/qemu-iotests/052
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/052
+++ b/tests/qemu-iotests/052
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto file
 
 # Don't do O_DIRECT on tmpfs
-_supported_cache_modes "writeback" "writethrough" "unsafe"
+_supported_cache_modes writeback writethrough unsafe
 
 size=128M
 _make_test_img $size
diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/091
+++ b/tests/qemu-iotests/091
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
-_default_cache_mode "none"
-_supported_cache_modes "writethrough" "none" "writeback"
+_default_cache_mode none
+_supported_cache_modes writethrough none writeback
 
 size=1G
 
-- 
2.21.0