Series comparison

-[Qemu-devel] [PULL 00/12] Block patches
+[PULL 00/14] Block patches
-The following changes since commit bfec359afba088aaacc7d316f43302f28c6e642a:
+The following changes since commit f5fe7c17ac4e309e47e78f0f9761aebc8d2f2c81:
-  Merge remote-tracking branch 'remotes/armbru/tags/pull-qdev-2017-04-21' into staging (2017-04-21 11:42:03 +0100)
+  Merge tag 'pull-tcg-20230823-2' of https://gitlab.com/rth7680/qemu into staging (2023-08-28 16:07:04 -0400)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request
+  https://gitlab.com/hreitz/qemu.git tags/pull-block-2023-09-01
-for you to fetch changes up to 1507631e438930bc07f776f303af127a9cdb4d41:
+for you to fetch changes up to 380448464dd89291cf7fd7434be6c225482a334d:
-  qemu-iotests: _cleanup_qemu must be called on exit (2017-04-21 08:32:44 -0400)
+  tests/file-io-error: New test (2023-08-29 13:01:24 +0200)
 ----------------------------------------------------------------
+Block patches
-Block patches for 2.10
+- Fix for file-posix's zoning code crashing on I/O errors
 - Throttling refactoring
 ----------------------------------------------------------------
+Hanna Czenczek (5):
+  file-posix: Clear bs->bl.zoned on error
+  file-posix: Check bs->bl.zoned for zone info
+  file-posix: Fix zone update in I/O error path
+  file-posix: Simplify raw_co_prw's 'out' zone code
+  tests/file-io-error: New test
-Ashish Mittal (2):
+Zhenwei Pi (9):
-  block/vxhs.c: Add support for a new block device type called "vxhs"
+  throttle: introduce enum ThrottleDirection
-  block/vxhs.c: Add qemu-iotests for new block device type "vxhs"
+  test-throttle: use enum ThrottleDirection
   throttle: support read-only and write-only
   test-throttle: test read only and write only
   cryptodev: use NULL throttle timer cb for read direction
   throttle: use enum ThrottleDirection instead of bool is_write
   throttle: use THROTTLE_MAX/ARRAY_SIZE for hard code
   fsdev: Use ThrottleDirection instread of bool is_write
   block/throttle-groups: Use ThrottleDirection instread of bool is_write
-Jeff Cody (10):
+ fsdev/qemu-fsdev-throttle.h                |   4 +-
-  qemu-iotests: exclude vxhs from image creation via protocol
+ include/block/throttle-groups.h            |   6 +-
-  block: add bdrv_set_read_only() helper function
+ include/qemu/throttle.h                    |  16 +-
-  block: do not set BDS read_only if copy_on_read enabled
+ backends/cryptodev.c                       |  12 +-
-  block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
+ block/block-backend.c                      |   4 +-
-  block: code movement
+ block/file-posix.c                         |  42 +++---
-  block: introduce bdrv_can_set_read_only()
+ block/throttle-groups.c                    | 163 +++++++++++----------
-  block: use bdrv_can_set_read_only() during reopen
+ block/throttle.c                           |   8 +-
-  block/rbd - update variable names to more apt names
+ fsdev/qemu-fsdev-throttle.c                |  18 ++-
-  block/rbd: Add support for reopen()
+ hw/9pfs/cofile.c                           |   4 +-
-  qemu-iotests: _cleanup_qemu must be called on exit
+ tests/unit/test-throttle.c                 |  76 +++++++++-
+ util/throttle.c                            |  84 +++++++----
- block.c                          |  56 +++-
+ tests/qemu-iotests/tests/file-io-error     | 119 +++++++++++++++
- block/Makefile.objs              |   2 +
+ tests/qemu-iotests/tests/file-io-error.out |  33 +++++
- block/bochs.c                    |   5 +-
+files changed, 418 insertions(+), 171 deletions(-)
- block/cloop.c                    |   5 +-
+ create mode 100755 tests/qemu-iotests/tests/file-io-error
- block/dmg.c                      |   6 +-
+ create mode 100644 tests/qemu-iotests/tests/file-io-error.out
  block/rbd.c                      |  65 +++--
  block/trace-events               |  17 ++
  block/vvfat.c                    |  19 +-
  block/vxhs.c                     | 575 +++++++++++++++++++++++++++++++++++++++
  configure                        |  39 +++
  include/block/block.h            |   2 +
  qapi/block-core.json             |  23 +-
  tests/qemu-iotests/017           |   1 +
  tests/qemu-iotests/020           |   1 +
  tests/qemu-iotests/028           |   1 +
  tests/qemu-iotests/029           |   1 +
  tests/qemu-iotests/073           |   1 +
  tests/qemu-iotests/094           |  11 +-
  tests/qemu-iotests/102           |   5 +-
  tests/qemu-iotests/109           |   1 +
  tests/qemu-iotests/114           |   1 +
  tests/qemu-iotests/117           |   1 +
  tests/qemu-iotests/130           |   2 +
  tests/qemu-iotests/134           |   1 +
  tests/qemu-iotests/140           |   1 +
  tests/qemu-iotests/141           |   1 +
  tests/qemu-iotests/143           |   1 +
  tests/qemu-iotests/156           |   2 +
  tests/qemu-iotests/158           |   1 +
  tests/qemu-iotests/common        |   6 +
  tests/qemu-iotests/common.config |  13 +
  tests/qemu-iotests/common.filter |   1 +
  tests/qemu-iotests/common.rc     |  19 ++
 files changed, 844 insertions(+), 42 deletions(-)
  create mode 100644 block/vxhs.c
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 11/12] block/rbd: Add support for reopen()
+[PULL 01/14] throttle: introduce enum ThrottleDirection
-This adds support for reopen in rbd, for changing between r/w and r/o.
+From: zhenwei pi <pizhenwei@bytedance.com>
-Note, that this is only a flag change, but we will block a change from
+Use enum ThrottleDirection instead of number index.
 r/o to r/w if we are using an RBD internal snapshot.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
-Message-id: d4e87539167ec6527d44c97b164eabcccf96e4f3.1491597120.git.jcody@redhat.com
+Message-Id: <20230728022006.1098509-2-pizhenwei@bytedance.com>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
- block/rbd.c | 21 +++++++++++++++++++++
+ include/qemu/throttle.h | 11 ++++++++---
-file changed, 21 insertions(+)
+ util/throttle.c         | 16 +++++++++-------
 files changed, 17 insertions(+), 10 deletions(-)
-diff --git a/block/rbd.c b/block/rbd.c
+diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
+--- a/include/qemu/throttle.h
-+++ b/block/rbd.c
++++ b/include/qemu/throttle.h
-@@ -XXX,XX +XXX,XX @@ failed_opts:
+@@ -XXX,XX +XXX,XX @@ typedef struct ThrottleState {
-     return r;
+     int64_t previous_leak;    /* timestamp of the last leak done */
  } ThrottleState;
 +typedef enum {
 +    THROTTLE_READ = 0,
 +    THROTTLE_WRITE,
 +    THROTTLE_MAX
 +} ThrottleDirection;
 +
  typedef struct ThrottleTimers {
 -    QEMUTimer *timers[2];     /* timers used to do the throttling */
 +    QEMUTimer *timers[THROTTLE_MAX];    /* timers used to do the throttling */
      QEMUClockType clock_type; /* the clock used */
      /* Callbacks */
 -    QEMUTimerCB *read_timer_cb;
 -    QEMUTimerCB *write_timer_cb;
 +    QEMUTimerCB *timer_cb[THROTTLE_MAX];
      void *timer_opaque;
  } ThrottleTimers;
 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 bool throttle_compute_timer(ThrottleState *ts,
  void throttle_timers_attach_aio_context(ThrottleTimers *tt,
                                          AioContext *new_context)
  {
 -    tt->timers[0] = aio_timer_new(new_context, tt->clock_type, SCALE_NS,
 -                                  tt->read_timer_cb, tt->timer_opaque);
 -    tt->timers[1] = aio_timer_new(new_context, tt->clock_type, SCALE_NS,
 -                                  tt->write_timer_cb, tt->timer_opaque);
 +    tt->timers[THROTTLE_READ] =
 +        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
 +                      tt->timer_cb[THROTTLE_READ], tt->timer_opaque);
 +    tt->timers[THROTTLE_WRITE] =
 +        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
 +                      tt->timer_cb[THROTTLE_WRITE], tt->timer_opaque);
  }
-+
+ /*
-+/* Since RBD is currently always opened R/W via the API,
+@@ -XXX,XX +XXX,XX @@ void throttle_timers_init(ThrottleTimers *tt,
-+ * we just need to check if we are using a snapshot or not, in
+     memset(tt, 0, sizeof(ThrottleTimers));
-+ * order to determine if we will allow it to be R/W */
-+static int qemu_rbd_reopen_prepare(BDRVReopenState *state,
+     tt->clock_type = clock_type;
-+                                   BlockReopenQueue *queue, Error **errp)
+-    tt->read_timer_cb = read_timer_cb;
-+{
+-    tt->write_timer_cb = write_timer_cb;
-+    BDRVRBDState *s = state->bs->opaque;
++    tt->timer_cb[THROTTLE_READ] = read_timer_cb;
-+    int ret = 0;
++    tt->timer_cb[THROTTLE_WRITE] = write_timer_cb;
-+
+     tt->timer_opaque = timer_opaque;
-+    if (s->snap && state->flags & BDRV_O_RDWR) {
+     throttle_timers_attach_aio_context(tt, aio_context);
-+        error_setg(errp,
+ }
-+                   "Cannot change node '%s' to r/w when using RBD snapshot",
+@@ -XXX,XX +XXX,XX @@ void throttle_timers_detach_aio_context(ThrottleTimers *tt)
 +                   bdrv_get_device_or_node_name(state->bs));
 +        ret = -EINVAL;
 +    }
 +
 +    return ret;
 +}
 +
  static void qemu_rbd_close(BlockDriverState *bs)
  {
-     BDRVRBDState *s = bs->opaque;
+     int i;
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {
-     .bdrv_parse_filename    = qemu_rbd_parse_filename,
+-    for (i = 0; i < 2; i++) {
-     .bdrv_file_open         = qemu_rbd_open,
++    for (i = 0; i < THROTTLE_MAX; i++) {
-     .bdrv_close             = qemu_rbd_close,
+         throttle_timer_destroy(&tt->timers[i]);
-+    .bdrv_reopen_prepare    = qemu_rbd_reopen_prepare,
+     }
-     .bdrv_create            = qemu_rbd_create,
+ }
      .bdrv_has_zero_init     = bdrv_has_zero_init_1,
      .bdrv_get_info          = qemu_rbd_getinfo,
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 07/12] block: code movement
+[PULL 02/14] test-throttle: use enum ThrottleDirection
-Move bdrv_is_read_only() up with its friends.
+From: zhenwei pi <pizhenwei@bytedance.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Use enum ThrottleDirection instead in the throttle test codes.
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
-Message-id: 73b2399459760c32506f9407efb9dddb3a2789de.1491597120.git.jcody@redhat.com
+Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
 Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
 Message-Id: <20230728022006.1098509-3-pizhenwei@bytedance.com>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
- block.c | 10 +++++-----
+ tests/unit/test-throttle.c | 6 +++---
-file changed, 5 insertions(+), 5 deletions(-)
+file changed, 3 insertions(+), 3 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/tests/unit/test-throttle.c b/tests/unit/test-throttle.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/tests/unit/test-throttle.c
-+++ b/block.c
++++ b/tests/unit/test-throttle.c
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
+@@ -XXX,XX +XXX,XX @@ static void test_init(void)
      /* check initialized fields */
      g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
 -    g_assert(tt->timers[0]);
 -    g_assert(tt->timers[1]);
 +    g_assert(tt->timers[THROTTLE_READ]);
 +    g_assert(tt->timers[THROTTLE_WRITE]);
      /* check other fields where cleared */
      g_assert(!ts.previous_leak);
@@ -XXX,XX +XXX,XX @@ static void test_destroy(void)
      throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
                           read_timer_cb, write_timer_cb, &ts);
      throttle_timers_destroy(tt);
 -    for (i = 0; i < 2; i++) {
 +    for (i = 0; i < THROTTLE_MAX; i++) {
          g_assert(!tt->timers[i]);
      }
  }
-+bool bdrv_is_read_only(BlockDriverState *bs)
-+{
-+    return bs->read_only;
-+}
-+
- int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
- {
-     /* Do not set read_only if copy_on_read is enabled */
-@@ -XXX,XX +XXX,XX @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
-     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
- }
--bool bdrv_is_read_only(BlockDriverState *bs)
--{
--    return bs->read_only;
--}
--
- bool bdrv_is_sg(BlockDriverState *bs)
- {
-     return bs->sg;
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 04/12] block: add bdrv_set_read_only() helper function
+[PULL 03/14] throttle: support read-only and write-only
-We have a helper wrapper for checking for the BDS read_only flag,
+From: zhenwei pi <pizhenwei@bytedance.com>
 add a helper wrapper to set the read_only flag as well.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Only one direction is necessary in several scenarios:
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+- a read-only disk
-Reviewed-by: John Snow <jsnow@redhat.com>
+- operations on a device are considered as *write* only. For example,
-Message-id: 9b18972d05f5fa2ac16c014f0af98d680553048d.1491597120.git.jcody@redhat.com
+  encrypt/decrypt/sign/verify operations on a cryptodev use a single
   *write* timer(read timer callback is defined, but never invoked).
 Allow a single direction in throttle, this reduces memory, and uplayer
 does not need a dummy callback any more.
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
 Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
 Message-Id: <20230728022006.1098509-4-pizhenwei@bytedance.com>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
- block.c               | 5 +++++
+ util/throttle.c | 42 ++++++++++++++++++++++++++++--------------
- block/bochs.c         | 2 +-
+file changed, 28 insertions(+), 14 deletions(-)
  block/cloop.c         | 2 +-
  block/dmg.c           | 2 +-
  block/rbd.c           | 2 +-
  block/vvfat.c         | 4 ++--
  include/block/block.h | 1 +
 files changed, 12 insertions(+), 6 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/util/throttle.c b/util/throttle.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/util/throttle.c
-+++ b/block.c
++++ b/util/throttle.c
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
+@@ -XXX,XX +XXX,XX @@ static bool throttle_compute_timer(ThrottleState *ts,
  void throttle_timers_attach_aio_context(ThrottleTimers *tt,
                                          AioContext *new_context)
  {
 -    tt->timers[THROTTLE_READ] =
 -        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
 -                      tt->timer_cb[THROTTLE_READ], tt->timer_opaque);
 -    tt->timers[THROTTLE_WRITE] =
 -        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
 -                      tt->timer_cb[THROTTLE_WRITE], tt->timer_opaque);
 +    ThrottleDirection dir;
 +
 +    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
 +        if (tt->timer_cb[dir]) {
 +            tt->timers[dir] =
 +                aio_timer_new(new_context, tt->clock_type, SCALE_NS,
 +                              tt->timer_cb[dir], tt->timer_opaque);
 +        }
 +    }
  }
  /*
@@ -XXX,XX +XXX,XX @@ void throttle_timers_init(ThrottleTimers *tt,
                            QEMUTimerCB *write_timer_cb,
                            void *timer_opaque)
  {
 +    assert(read_timer_cb || write_timer_cb);
      memset(tt, 0, sizeof(ThrottleTimers));
      tt->clock_type = clock_type;
@@ -XXX,XX +XXX,XX @@ void throttle_timers_init(ThrottleTimers *tt,
  /* destroy a timer */
  static void throttle_timer_destroy(QEMUTimer **timer)
  {
 -    assert(*timer != NULL);
 +    if (*timer == NULL) {
 +        return;
 +    }
      timer_free(*timer);
      *timer = NULL;
@@ -XXX,XX +XXX,XX @@ static void throttle_timer_destroy(QEMUTimer **timer)
  /* Remove timers from event loop */
  void throttle_timers_detach_aio_context(ThrottleTimers *tt)
  {
 -    int i;
 +    ThrottleDirection dir;
 -    for (i = 0; i < THROTTLE_MAX; i++) {
 -        throttle_timer_destroy(&tt->timers[i]);
 +    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
 +        throttle_timer_destroy(&tt->timers[dir]);
      }
  }
-+void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
+@@ -XXX,XX +XXX,XX @@ void throttle_timers_destroy(ThrottleTimers *tt)
-+{
+ /* is any throttling timer configured */
-+    bs->read_only = read_only;
+ bool throttle_timers_are_initialized(ThrottleTimers *tt)
-+}
+ {
 -    if (tt->timers[0]) {
 -        return true;
 +    ThrottleDirection dir;
 +
- void bdrv_get_full_backing_filename_from_filename(const char *backed,
++    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
-                                                   const char *backing,
++        if (tt->timers[dir]) {
-                                                   char *dest, size_t sz,
++            return true;
-diff --git a/block/bochs.c b/block/bochs.c
++        }
 index XXXXXXX..XXXXXXX 100644
 --- a/block/bochs.c
 +++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
          return -EINVAL;
      }
--    bs->read_only = true; /* no write support yet */
+     return false;
-+    bdrv_set_read_only(bs, true); /* no write support yet */
+@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
+ {
-     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
+     int64_t now = qemu_clock_get_ns(tt->clock_type);
-     if (ret < 0) {
+     int64_t next_timestamp;
-diff --git a/block/cloop.c b/block/cloop.c
++    QEMUTimer *timer;
-index XXXXXXX..XXXXXXX 100644
+     bool must_wait;
---- a/block/cloop.c
-+++ b/block/cloop.c
++    timer = is_write ? tt->timers[THROTTLE_WRITE] : tt->timers[THROTTLE_READ];
-@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
++    assert(timer);
-         return -EINVAL;
++
      must_wait = throttle_compute_timer(ts,
                                         is_write,
                                         now,
@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
      }
--    bs->read_only = true;
+     /* request throttled and timer pending -> do nothing */
-+    bdrv_set_read_only(bs, true);
+-    if (timer_pending(tt->timers[is_write])) {
++    if (timer_pending(timer)) {
-     /* read header */
+         return true;
      ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
 diff --git a/block/dmg.c b/block/dmg.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/dmg.c
 +++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
      }
-     block_module_load_one("dmg-bz2");
+     /* request throttled and timer not pending -> arm timer */
--    bs->read_only = true;
+-    timer_mod(tt->timers[is_write], next_timestamp);
-+    bdrv_set_read_only(bs, true);
++    timer_mod(timer, next_timestamp);
+     return true;
-     s->n_chunks = 0;
+ }
-     s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
          goto failed_open;
      }
 -    bs->read_only = (s->snap != NULL);
 +    bdrv_set_read_only(bs, (s->snap != NULL));
      qemu_opts_del(opts);
      return 0;
 diff --git a/block/vvfat.c b/block/vvfat.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vvfat.c
 +++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
      s->current_cluster=0xffffffff;
      /* read only is the default for safety */
 -    bs->read_only = true;
 +    bdrv_set_read_only(bs, true);
      s->qcow = NULL;
      s->qcow_filename = NULL;
      s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
          if (ret < 0) {
              goto fail;
          }
 -        bs->read_only = false;
 +        bdrv_set_read_only(bs, false);
      }
      bs->total_sectors = cyls * heads * secs;
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                              int64_t sector_num, int nb_sectors, int *pnum);
  bool bdrv_is_read_only(BlockDriverState *bs);
 +void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
  bool bdrv_is_sg(BlockDriverState *bs);
  bool bdrv_is_inserted(BlockDriverState *bs);
  int bdrv_media_changed(BlockDriverState *bs);
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 08/12] block: introduce bdrv_can_set_read_only()
+[PULL 04/14] test-throttle: test read only and write only
-Introduce check function for setting read_only flags.  Will return < 0 on
+From: zhenwei pi <pizhenwei@bytedance.com>
 error, with appropriate Error value set.  Does not alter any flags.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
-Message-id: e2bba34ac3bc76a0c42adc390413f358ae0566e8.1491597120.git.jcody@redhat.com
+Message-Id: <20230728022006.1098509-5-pizhenwei@bytedance.com>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
- block.c               | 14 +++++++++++++-
+ tests/unit/test-throttle.c | 66 ++++++++++++++++++++++++++++++++++++++
- include/block/block.h |  1 +
+file changed, 66 insertions(+)
 files changed, 14 insertions(+), 1 deletion(-)
-diff --git a/block.c b/block.c
+diff --git a/tests/unit/test-throttle.c b/tests/unit/test-throttle.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/tests/unit/test-throttle.c
-+++ b/block.c
++++ b/tests/unit/test-throttle.c
-@@ -XXX,XX +XXX,XX @@ bool bdrv_is_read_only(BlockDriverState *bs)
+@@ -XXX,XX +XXX,XX @@ static void test_init(void)
-     return bs->read_only;
+     throttle_timers_destroy(tt);
  }
--int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++static void test_init_readonly(void)
-+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++{
- {
++    int i;
-     /* Do not set read_only if copy_on_read is enabled */
++
-     if (bs->copy_on_read && read_only) {
++    tt = &tgm.throttle_timers;
-@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++
-         return -EPERM;
++    /* fill the structures with crap */
-     }
++    memset(&ts, 1, sizeof(ts));
++    memset(tt, 1, sizeof(*tt));
-+    return 0;
++
 +    /* init structures */
 +    throttle_init(&ts);
 +    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
 +                         read_timer_cb, NULL, &ts);
 +
 +    /* check initialized fields */
 +    g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
 +    g_assert(tt->timers[THROTTLE_READ]);
 +    g_assert(!tt->timers[THROTTLE_WRITE]);
 +
 +    /* check other fields where cleared */
 +    g_assert(!ts.previous_leak);
 +    g_assert(!ts.cfg.op_size);
 +    for (i = 0; i < BUCKETS_COUNT; i++) {
 +        g_assert(!ts.cfg.buckets[i].avg);
 +        g_assert(!ts.cfg.buckets[i].max);
 +        g_assert(!ts.cfg.buckets[i].level);
 +    }
 +
 +    throttle_timers_destroy(tt);
 +}
 +
-+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++static void test_init_writeonly(void)
 +{
-+    int ret = 0;
++    int i;
 +
-+    ret = bdrv_can_set_read_only(bs, read_only, errp);
++    tt = &tgm.throttle_timers;
-+    if (ret < 0) {
++
-+        return ret;
++    /* fill the structures with crap */
 +    memset(&ts, 1, sizeof(ts));
 +    memset(tt, 1, sizeof(*tt));
 +
 +    /* init structures */
 +    throttle_init(&ts);
 +    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
 +                         NULL, write_timer_cb, &ts);
 +
 +    /* check initialized fields */
 +    g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
 +    g_assert(!tt->timers[THROTTLE_READ]);
 +    g_assert(tt->timers[THROTTLE_WRITE]);
 +
 +    /* check other fields where cleared */
 +    g_assert(!ts.previous_leak);
 +    g_assert(!ts.cfg.op_size);
 +    for (i = 0; i < BUCKETS_COUNT; i++) {
 +        g_assert(!ts.cfg.buckets[i].avg);
 +        g_assert(!ts.cfg.buckets[i].max);
 +        g_assert(!ts.cfg.buckets[i].level);
 +    }
 +
-     bs->read_only = read_only;
++    throttle_timers_destroy(tt);
-     return 0;
++}
- }
++
-diff --git a/include/block/block.h b/include/block/block.h
+ static void test_destroy(void)
-index XXXXXXX..XXXXXXX 100644
+ {
---- a/include/block/block.h
+     int i;
-+++ b/include/block/block.h
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
+     g_test_add_func("/throttle/leak_bucket",        test_leak_bucket);
-                             int64_t sector_num, int nb_sectors, int *pnum);
+     g_test_add_func("/throttle/compute_wait",       test_compute_wait);
+     g_test_add_func("/throttle/init",               test_init);
- bool bdrv_is_read_only(BlockDriverState *bs);
++    g_test_add_func("/throttle/init_readonly",      test_init_readonly);
-+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
++    g_test_add_func("/throttle/init_writeonly",     test_init_writeonly);
- int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
+     g_test_add_func("/throttle/destroy",            test_destroy);
- bool bdrv_is_sg(BlockDriverState *bs);
+     g_test_add_func("/throttle/have_timer",         test_have_timer);
- bool bdrv_is_inserted(BlockDriverState *bs);
+     g_test_add_func("/throttle/detach_attach",      test_detach_attach);
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 10/12] block/rbd - update variable names to more apt names
+[PULL 05/14] cryptodev: use NULL throttle timer cb for read direction
-Update 'clientname' to be 'user', which tracks better with both
+From: zhenwei pi <pizhenwei@bytedance.com>
 the QAPI and rados variable naming.
-Update 'name' to be 'image_name', as it indicates the rbd image.
+Operations on a cryptodev are considered as *write* only, the callback
-Naming it 'image' would have been ideal, but we are using that for
+of read direction is never invoked. Use NULL instead of an unreachable
-the rados_image_t value returned by rbd_open().
+path(cryptodev_backend_throttle_timer_cb on read direction).
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+The dummy read timer(never invoked) is already removed here, it means
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+that the 'FIXME' tag is no longer needed.
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: b7ec1fb2e1cf36f9b6911631447a5b0422590b7d.1491597120.git.jcody@redhat.com
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
 Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
 Message-Id: <20230728022006.1098509-6-pizhenwei@bytedance.com>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
- block/rbd.c | 33 +++++++++++++++++----------------
+ backends/cryptodev.c | 3 +--
-file changed, 17 insertions(+), 16 deletions(-)
+file changed, 1 insertion(+), 2 deletions(-)
-diff --git a/block/rbd.c b/block/rbd.c
+diff --git a/backends/cryptodev.c b/backends/cryptodev.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
+--- a/backends/cryptodev.c
-+++ b/block/rbd.c
++++ b/backends/cryptodev.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRBDState {
+@@ -XXX,XX +XXX,XX @@ static void cryptodev_backend_set_throttle(CryptoDevBackend *backend, int field,
-     rados_t cluster;
+     if (!enabled) {
-     rados_ioctx_t io_ctx;
+         throttle_init(&backend->ts);
-     rbd_image_t image;
+         throttle_timers_init(&backend->tt, qemu_get_aio_context(),
--    char *name;
+-                             QEMU_CLOCK_REALTIME,
-+    char *image_name;
+-                             cryptodev_backend_throttle_timer_cb, /* FIXME */
-     char *snap;
++                             QEMU_CLOCK_REALTIME, NULL,
- } BDRVRBDState;
+                              cryptodev_backend_throttle_timer_cb, backend);
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
      int64_t bytes = 0;
      int64_t objsize;
      int obj_order = 0;
 -    const char *pool, *name, *conf, *clientname, *keypairs;
 +    const char *pool, *image_name, *conf, *user, *keypairs;
      const char *secretid;
      rados_t cluster;
      rados_ioctx_t io_ctx;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
       */
      pool       = qdict_get_try_str(options, "pool");
      conf       = qdict_get_try_str(options, "conf");
 -    clientname = qdict_get_try_str(options, "user");
 -    name       = qdict_get_try_str(options, "image");
 +    user       = qdict_get_try_str(options, "user");
 +    image_name = qdict_get_try_str(options, "image");
      keypairs   = qdict_get_try_str(options, "=keyvalue-pairs");
 -    ret = rados_create(&cluster, clientname);
 +    ret = rados_create(&cluster, user);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "error initializing");
          goto exit;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
          goto shutdown;
      }
--    ret = rbd_create(io_ctx, name, bytes, &obj_order);
-+    ret = rbd_create(io_ctx, image_name, bytes, &obj_order);
-     if (ret < 0) {
-         error_setg_errno(errp, -ret, "error rbd create");
-     }
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
-                          Error **errp)
- {
-     BDRVRBDState *s = bs->opaque;
--    const char *pool, *snap, *conf, *clientname, *name, *keypairs;
-+    const char *pool, *snap, *conf, *user, *image_name, *keypairs;
-     const char *secretid;
-     QemuOpts *opts;
-     Error *local_err = NULL;
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
-     pool           = qemu_opt_get(opts, "pool");
-     conf           = qemu_opt_get(opts, "conf");
-     snap           = qemu_opt_get(opts, "snapshot");
--    clientname     = qemu_opt_get(opts, "user");
--    name           = qemu_opt_get(opts, "image");
-+    user           = qemu_opt_get(opts, "user");
-+    image_name     = qemu_opt_get(opts, "image");
-     keypairs       = qemu_opt_get(opts, "=keyvalue-pairs");
--    if (!pool || !name) {
-+    if (!pool || !image_name) {
-         error_setg(errp, "Parameters 'pool' and 'image' are required");
-         r = -EINVAL;
-         goto failed_opts;
-     }
--    r = rados_create(&s->cluster, clientname);
-+    r = rados_create(&s->cluster, user);
-     if (r < 0) {
-         error_setg_errno(errp, -r, "error initializing");
-         goto failed_opts;
-     }
-     s->snap = g_strdup(snap);
--    s->name = g_strdup(name);
-+    s->image_name = g_strdup(image_name);
-     /* try default location when conf=NULL, but ignore failure */
-     r = rados_conf_read_file(s->cluster, conf);
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
-     }
-     /* rbd_open is always r/w */
--    r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
-+    r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap);
-     if (r < 0) {
--        error_setg_errno(errp, -r, "error reading header from %s", s->name);
-+        error_setg_errno(errp, -r, "error reading header from %s",
-+                         s->image_name);
-         goto failed_open;
-     }
-@@ -XXX,XX +XXX,XX @@ failed_open:
- failed_shutdown:
-     rados_shutdown(s->cluster);
-     g_free(s->snap);
--    g_free(s->name);
-+    g_free(s->image_name);
- failed_opts:
-     qemu_opts_del(opts);
-     g_free(mon_host);
-@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_close(BlockDriverState *bs)
-     rbd_close(s->image);
-     rados_ioctx_destroy(s->io_ctx);
-     g_free(s->snap);
--    g_free(s->name);
-+    g_free(s->image_name);
-     rados_shutdown(s->cluster);
- }
 --
-.9.3
+.41.0

-New patch
+[PULL 06/14] throttle: use enum ThrottleDirection instead of bool is_write
+From: zhenwei pi <pizhenwei@bytedance.com>
+enum ThrottleDirection is already there, use ThrottleDirection instead
+of 'bool is_write' for throttle API, also modify related codes from
+block, fsdev, cryptodev and tests.
+Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
+Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
+Message-Id: <20230728022006.1098509-7-pizhenwei@bytedance.com>
+Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
+---
+ include/qemu/throttle.h     |  5 +++--
+ backends/cryptodev.c        |  9 +++++----
+ block/throttle-groups.c     |  6 ++++--
+ fsdev/qemu-fsdev-throttle.c |  8 +++++---
+ tests/unit/test-throttle.c  |  4 ++--
+ util/throttle.c             | 31 +++++++++++++++++--------------
+files changed, 36 insertions(+), 27 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 @@ void throttle_config_init(ThrottleConfig *cfg);
+ /* usage */
+ bool throttle_schedule_timer(ThrottleState *ts,
+                              ThrottleTimers *tt,
+-                             bool is_write);
++                             ThrottleDirection direction);
+-void throttle_account(ThrottleState *ts, bool is_write, uint64_t size);
++void throttle_account(ThrottleState *ts, ThrottleDirection direction,
++                      uint64_t size);
+ void throttle_limits_to_config(ThrottleLimits *arg, ThrottleConfig *cfg,
+                                Error **errp);
+ void throttle_config_to_limits(ThrottleConfig *cfg, ThrottleLimits *var);
+diff --git a/backends/cryptodev.c b/backends/cryptodev.c
+index XXXXXXX..XXXXXXX 100644
+--- a/backends/cryptodev.c
++++ b/backends/cryptodev.c
+@@ -XXX,XX +XXX,XX @@ static void cryptodev_backend_throttle_timer_cb(void *opaque)
+             continue;
+         }
+-        throttle_account(&backend->ts, true, ret);
++        throttle_account(&backend->ts, THROTTLE_WRITE, ret);
+         cryptodev_backend_operation(backend, op_info);
+         if (throttle_enabled(&backend->tc) &&
+-            throttle_schedule_timer(&backend->ts, &backend->tt, true)) {
++            throttle_schedule_timer(&backend->ts, &backend->tt,
++                                    THROTTLE_WRITE)) {
+             break;
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ int cryptodev_backend_crypto_operation(
+         goto do_account;
+     }
+-    if (throttle_schedule_timer(&backend->ts, &backend->tt, true) ||
++    if (throttle_schedule_timer(&backend->ts, &backend->tt, THROTTLE_WRITE) ||
+         !QTAILQ_EMPTY(&backend->opinfos)) {
+         QTAILQ_INSERT_TAIL(&backend->opinfos, op_info, next);
+         return 0;
+@@ -XXX,XX +XXX,XX @@ do_account:
+         return ret;
+     }
+-    throttle_account(&backend->ts, true, ret);
++    throttle_account(&backend->ts, THROTTLE_WRITE, ret);
+     return cryptodev_backend_operation(backend, op_info);
+ }
+diff --git a/block/throttle-groups.c b/block/throttle-groups.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/throttle-groups.c
++++ b/block/throttle-groups.c
+@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
+     ThrottleState *ts = tgm->throttle_state;
+     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+     ThrottleTimers *tt = &tgm->throttle_timers;
++    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
+     bool must_wait;
+     if (qatomic_read(&tgm->io_limits_disabled)) {
+@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
+         return true;
+     }
+-    must_wait = throttle_schedule_timer(ts, tt, is_write);
++    must_wait = throttle_schedule_timer(ts, tt, direction);
+     /* If a timer just got armed, set tgm as the current token */
+     if (must_wait) {
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm
+     bool must_wait;
+     ThrottleGroupMember *token;
+     ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
++    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
+     assert(bytes >= 0);
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm
+     }
+     /* The I/O will be executed, so do the accounting */
+-    throttle_account(tgm->throttle_state, is_write, bytes);
++    throttle_account(tgm->throttle_state, direction, bytes);
+     /* Schedule the next request */
+     schedule_next_request(tgm, is_write);
+diff --git a/fsdev/qemu-fsdev-throttle.c b/fsdev/qemu-fsdev-throttle.c
+index XXXXXXX..XXXXXXX 100644
+--- a/fsdev/qemu-fsdev-throttle.c
++++ b/fsdev/qemu-fsdev-throttle.c
+@@ -XXX,XX +XXX,XX @@ void fsdev_throttle_init(FsThrottle *fst)
+ void coroutine_fn fsdev_co_throttle_request(FsThrottle *fst, bool is_write,
+                                             struct iovec *iov, int iovcnt)
+ {
++    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
++
+     if (throttle_enabled(&fst->cfg)) {
+-        if (throttle_schedule_timer(&fst->ts, &fst->tt, is_write) ||
++        if (throttle_schedule_timer(&fst->ts, &fst->tt, direction) ||
+             !qemu_co_queue_empty(&fst->throttled_reqs[is_write])) {
+             qemu_co_queue_wait(&fst->throttled_reqs[is_write], NULL);
+         }
+-        throttle_account(&fst->ts, is_write, iov_size(iov, iovcnt));
++        throttle_account(&fst->ts, direction, iov_size(iov, iovcnt));
+         if (!qemu_co_queue_empty(&fst->throttled_reqs[is_write]) &&
+-            !throttle_schedule_timer(&fst->ts, &fst->tt, is_write)) {
++            !throttle_schedule_timer(&fst->ts, &fst->tt, direction)) {
+             qemu_co_queue_next(&fst->throttled_reqs[is_write]);
+         }
+     }
+diff --git a/tests/unit/test-throttle.c b/tests/unit/test-throttle.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-throttle.c
++++ b/tests/unit/test-throttle.c
+@@ -XXX,XX +XXX,XX @@ static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
+     throttle_config(&ts, QEMU_CLOCK_VIRTUAL, &cfg);
+     /* account a read */
+-    throttle_account(&ts, false, size);
++    throttle_account(&ts, THROTTLE_READ, size);
+     /* account a write */
+-    throttle_account(&ts, true, size);
++    throttle_account(&ts, THROTTLE_WRITE, size);
+     /* check total result */
+     index = to_test[is_ops][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 @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
+ /* This function compute the time that must be waited while this IO
+  *
+- * @is_write:   true if the current IO is a write, false if it's a read
++ * @direction:  throttle direction
+  * @ret:        time to wait
+  */
+ static int64_t throttle_compute_wait_for(ThrottleState *ts,
+-                                         bool is_write)
++                                         ThrottleDirection direction)
+ {
+     BucketType to_check[2][4] = { {THROTTLE_BPS_TOTAL,
+                                    THROTTLE_OPS_TOTAL,
+@@ -XXX,XX +XXX,XX @@ static int64_t throttle_compute_wait_for(ThrottleState *ts,
+     int i;
+     for (i = 0; i < 4; i++) {
+-        BucketType index = to_check[is_write][i];
++        BucketType index = to_check[direction][i];
+         wait = throttle_compute_wait(&ts->cfg.buckets[index]);
+         if (wait > max_wait) {
+             max_wait = wait;
+@@ -XXX,XX +XXX,XX @@ static int64_t throttle_compute_wait_for(ThrottleState *ts,
+ /* compute the timer for this type of operation
+  *
+- * @is_write:   the type of operation
++ * @direction:  throttle direction
+  * @now:        the current clock timestamp
+  * @next_timestamp: the resulting timer
+  * @ret:        true if a timer must be set
+  */
+ static bool throttle_compute_timer(ThrottleState *ts,
+-                                   bool is_write,
++                                   ThrottleDirection direction,
+                                    int64_t now,
+                                    int64_t *next_timestamp)
+ {
+@@ -XXX,XX +XXX,XX @@ static bool throttle_compute_timer(ThrottleState *ts,
+     throttle_do_leak(ts, now);
+     /* compute the wait time if any */
+-    wait = throttle_compute_wait_for(ts, is_write);
++    wait = throttle_compute_wait_for(ts, direction);
+     /* if the code must wait compute when the next timer should fire */
+     if (wait) {
+@@ -XXX,XX +XXX,XX @@ void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
+  * NOTE: this function is not unit tested due to it's usage of timer_mod
+  *
+  * @tt:       the timers structure
+- * @is_write: the type of operation (read/write)
++ * @direction: throttle direction
+  * @ret:      true if the timer has been scheduled else false
+  */
+ bool throttle_schedule_timer(ThrottleState *ts,
+                              ThrottleTimers *tt,
+-                             bool is_write)
++                             ThrottleDirection direction)
+ {
+     int64_t now = qemu_clock_get_ns(tt->clock_type);
+     int64_t next_timestamp;
+     QEMUTimer *timer;
+     bool must_wait;
+-    timer = is_write ? tt->timers[THROTTLE_WRITE] : tt->timers[THROTTLE_READ];
++    assert(direction < THROTTLE_MAX);
++    timer = tt->timers[direction];
+     assert(timer);
+     must_wait = throttle_compute_timer(ts,
+-                                       is_write,
++                                       direction,
+                                        now,
+                                        &next_timestamp);
+@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
+ /* do the accounting for this operation
+  *
+- * @is_write: the type of operation (read/write)
++ * @direction: throttle direction
+  * @size:     the size of the operation
+  */
+-void throttle_account(ThrottleState *ts, bool is_write, uint64_t size)
++void throttle_account(ThrottleState *ts, ThrottleDirection direction,
++                      uint64_t size)
+ {
+     const BucketType bucket_types_size[2][2] = {
+         { THROTTLE_BPS_TOTAL, THROTTLE_BPS_READ },
+@@ -XXX,XX +XXX,XX @@ void throttle_account(ThrottleState *ts, bool is_write, uint64_t size)
+     double units = 1.0;
+     unsigned i;
++    assert(direction < THROTTLE_MAX);
+     /* if cfg.op_size is defined and smaller than size we compute unit count */
+     if (ts->cfg.op_size && size > ts->cfg.op_size) {
+         units = (double) size / ts->cfg.op_size;
+@@ -XXX,XX +XXX,XX @@ void throttle_account(ThrottleState *ts, bool is_write, uint64_t size)
+     for (i = 0; i < 2; i++) {
+         LeakyBucket *bkt;
+-        bkt = &ts->cfg.buckets[bucket_types_size[is_write][i]];
++        bkt = &ts->cfg.buckets[bucket_types_size[direction][i]];
+         bkt->level += size;
+         if (bkt->burst_length > 1) {
+             bkt->burst_level += size;
+         }
+-        bkt = &ts->cfg.buckets[bucket_types_units[is_write][i]];
++        bkt = &ts->cfg.buckets[bucket_types_units[direction][i]];
+         bkt->level += units;
+         if (bkt->burst_length > 1) {
+             bkt->burst_level += units;
+--
+.41.0

-[Qemu-devel] [PULL 09/12] block: use bdrv_can_set_read_only() during reopen
+[PULL 07/14] throttle: use THROTTLE_MAX/ARRAY_SIZE for hard code
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+From: zhenwei pi <pizhenwei@bytedance.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+The first dimension of both to_check and
-Message-id: 00aed7ffdd7be4b9ed9ce1007d50028a72b34ebe.1491597120.git.jcody@redhat.com
+bucket_types_size/bucket_types_units is used as throttle direction,
 use THROTTLE_MAX instead of hard coded number. Also use ARRAY_SIZE()
 to avoid hard coded number for the second dimension.
 Hanna noticed that the two array should be static. Yes, turn them
 into static variables.
 Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
 Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
 Message-Id: <20230728022006.1098509-8-pizhenwei@bytedance.com>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
- block.c | 14 ++++++++------
+ util/throttle.c | 11 ++++++-----
-file changed, 8 insertions(+), 6 deletions(-)
+file changed, 6 insertions(+), 5 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/util/throttle.c b/util/throttle.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/util/throttle.c
-+++ b/block.c
++++ b/util/throttle.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
+@@ -XXX,XX +XXX,XX @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
-     BlockDriver *drv;
+ static int64_t throttle_compute_wait_for(ThrottleState *ts,
-     QemuOpts *opts;
+                                          ThrottleDirection direction)
-     const char *value;
+ {
-+    bool read_only;
+-    BucketType to_check[2][4] = { {THROTTLE_BPS_TOTAL,
++    static const BucketType to_check[THROTTLE_MAX][4] = {
-     assert(reopen_state != NULL);
++                                  {THROTTLE_BPS_TOTAL,
-     assert(reopen_state->bs->drv != NULL);
+                                    THROTTLE_OPS_TOTAL,
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
+                                    THROTTLE_BPS_READ,
-         qdict_put(reopen_state->options, "driver", qstring_from_str(value));
+                                    THROTTLE_OPS_READ},
@@ -XXX,XX +XXX,XX @@ static int64_t throttle_compute_wait_for(ThrottleState *ts,
      int64_t wait, max_wait = 0;
      int i;
 -    for (i = 0; i < 4; i++) {
 +    for (i = 0; i < ARRAY_SIZE(to_check[THROTTLE_READ]); i++) {
          BucketType index = to_check[direction][i];
          wait = throttle_compute_wait(&ts->cfg.buckets[index]);
          if (wait > max_wait) {
@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
  void throttle_account(ThrottleState *ts, ThrottleDirection direction,
                        uint64_t size)
  {
 -    const BucketType bucket_types_size[2][2] = {
 +    static const BucketType bucket_types_size[THROTTLE_MAX][2] = {
          { THROTTLE_BPS_TOTAL, THROTTLE_BPS_READ },
          { THROTTLE_BPS_TOTAL, THROTTLE_BPS_WRITE }
      };
 -    const BucketType bucket_types_units[2][2] = {
 +    static const BucketType bucket_types_units[THROTTLE_MAX][2] = {
          { THROTTLE_OPS_TOTAL, THROTTLE_OPS_READ },
          { THROTTLE_OPS_TOTAL, THROTTLE_OPS_WRITE }
      };
@@ -XXX,XX +XXX,XX @@ void throttle_account(ThrottleState *ts, ThrottleDirection direction,
          units = (double) size / ts->cfg.op_size;
      }
--    /* if we are to stay read-only, do not allow permission change
+-    for (i = 0; i < 2; i++) {
--     * to r/w */
++    for (i = 0; i < ARRAY_SIZE(bucket_types_size[THROTTLE_READ]); i++) {
--    if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
+         LeakyBucket *bkt;
--        reopen_state->flags & BDRV_O_RDWR) {
--        error_setg(errp, "Node '%s' is read only",
+         bkt = &ts->cfg.buckets[bucket_types_size[direction][i]];
 -                   bdrv_get_device_or_node_name(reopen_state->bs));
 +    /* If we are to stay read-only, do not allow permission change
 +     * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
 +     * not set, or if the BDS still has copy_on_read enabled */
 +    read_only = !(reopen_state->flags & BDRV_O_RDWR);
 +    ret = bdrv_can_set_read_only(reopen_state->bs, read_only, &local_err);
 +    if (local_err) {
 +        error_propagate(errp, local_err);
          goto error;
      }
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 05/12] block: do not set BDS read_only if copy_on_read enabled
+[PULL 08/14] fsdev: Use ThrottleDirection instread of bool is_write
-A few block drivers will set the BDS read_only flag from their
+From: zhenwei pi <pizhenwei@bytedance.com>
 .bdrv_open() function.  This means the bs->read_only flag could
 be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ
 flag check occurs prior to the call to bdrv->bdrv_open().
-This adds an error return to bdrv_set_read_only(), and an error will be
+'bool is_write' style is obsolete from throttle framework, adapt
-return if we try to set the BDS to read_only while copy_on_read is
+fsdev to the new style.
 enabled.
-This patch also changes the behavior of vvfat.  Before, vvfat could
+Cc: Greg Kurz <groug@kaod.org>
-override the drive 'readonly' flag with its own, internal 'rw' flag.
+Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
 Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
 Message-Id: <20230728022006.1098509-9-pizhenwei@bytedance.com>
 Reviewed-by: Greg Kurz <groug@kaod.org>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
  fsdev/qemu-fsdev-throttle.h |  4 ++--
  fsdev/qemu-fsdev-throttle.c | 14 +++++++-------
  hw/9pfs/cofile.c            |  4 ++--
 files changed, 11 insertions(+), 11 deletions(-)
-For instance, this -drive parameter would result in a writable image:
+diff --git a/fsdev/qemu-fsdev-throttle.h b/fsdev/qemu-fsdev-throttle.h
 "-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"
 This is not correct.  Now, attempting to use the above -drive parameter
 will result in an error (i.e., 'rw' is incompatible with 'readonly=on').
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Message-id: 0c5b4c1cc2c651471b131f21376dfd5ea24d2196.1491597120.git.jcody@redhat.com
 ---
  block.c               | 10 +++++++++-
  block/bochs.c         |  5 ++++-
  block/cloop.c         |  5 ++++-
  block/dmg.c           |  6 +++++-
  block/rbd.c           | 11 ++++++++++-
  block/vvfat.c         | 19 +++++++++++++++----
  include/block/block.h |  2 +-
 files changed, 48 insertions(+), 10 deletions(-)
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/fsdev/qemu-fsdev-throttle.h
-+++ b/block.c
++++ b/fsdev/qemu-fsdev-throttle.h
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
+@@ -XXX,XX +XXX,XX @@ typedef struct FsThrottle {
      ThrottleState ts;
      ThrottleTimers tt;
      ThrottleConfig cfg;
 -    CoQueue      throttled_reqs[2];
 +    CoQueue      throttled_reqs[THROTTLE_MAX];
  } FsThrottle;
  int fsdev_throttle_parse_opts(QemuOpts *, FsThrottle *, Error **);
  void fsdev_throttle_init(FsThrottle *);
 -void coroutine_fn fsdev_co_throttle_request(FsThrottle *, bool ,
 +void coroutine_fn fsdev_co_throttle_request(FsThrottle *, ThrottleDirection ,
                                              struct iovec *, int);
  void fsdev_throttle_cleanup(FsThrottle *);
 diff --git a/fsdev/qemu-fsdev-throttle.c b/fsdev/qemu-fsdev-throttle.c
 index XXXXXXX..XXXXXXX 100644
 --- a/fsdev/qemu-fsdev-throttle.c
 +++ b/fsdev/qemu-fsdev-throttle.c
@@ -XXX,XX +XXX,XX @@ void fsdev_throttle_init(FsThrottle *fst)
      }
  }
--void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
+-void coroutine_fn fsdev_co_throttle_request(FsThrottle *fst, bool is_write,
-+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++void coroutine_fn fsdev_co_throttle_request(FsThrottle *fst,
 +                                            ThrottleDirection direction,
                                              struct iovec *iov, int iovcnt)
  {
-+    /* Do not set read_only if copy_on_read is enabled */
+-    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
-+    if (bs->copy_on_read && read_only) {
+-
-+        error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
++    assert(direction < THROTTLE_MAX);
-+                   bdrv_get_device_or_node_name(bs));
+     if (throttle_enabled(&fst->cfg)) {
-+        return -EINVAL;
+         if (throttle_schedule_timer(&fst->ts, &fst->tt, direction) ||
-+    }
+-            !qemu_co_queue_empty(&fst->throttled_reqs[is_write])) {
-+
+-            qemu_co_queue_wait(&fst->throttled_reqs[is_write], NULL);
-     bs->read_only = read_only;
++            !qemu_co_queue_empty(&fst->throttled_reqs[direction])) {
-+    return 0;
++            qemu_co_queue_wait(&fst->throttled_reqs[direction], NULL);
          }
          throttle_account(&fst->ts, direction, iov_size(iov, iovcnt));
 -        if (!qemu_co_queue_empty(&fst->throttled_reqs[is_write]) &&
 +        if (!qemu_co_queue_empty(&fst->throttled_reqs[direction]) &&
              !throttle_schedule_timer(&fst->ts, &fst->tt, direction)) {
 -            qemu_co_queue_next(&fst->throttled_reqs[is_write]);
 +            qemu_co_queue_next(&fst->throttled_reqs[direction]);
          }
      }
  }
+diff --git a/hw/9pfs/cofile.c b/hw/9pfs/cofile.c
  void bdrv_get_full_backing_filename_from_filename(const char *backed,
 diff --git a/block/bochs.c b/block/bochs.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/bochs.c
+--- a/hw/9pfs/cofile.c
-+++ b/block/bochs.c
++++ b/hw/9pfs/cofile.c
-@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn v9fs_co_pwritev(V9fsPDU *pdu, V9fsFidState *fidp,
-         return -EINVAL;
+     if (v9fs_request_cancelled(pdu)) {
          return -EINTR;
      }
+-    fsdev_co_throttle_request(s->ctx.fst, true, iov, iovcnt);
--    bdrv_set_read_only(bs, true); /* no write support yet */
++    fsdev_co_throttle_request(s->ctx.fst, THROTTLE_WRITE, iov, iovcnt);
-+    ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */
+     v9fs_co_run_in_worker(
-+    if (ret < 0) {
+         {
-+        return ret;
+             err = s->ops->pwritev(&s->ctx, &fidp->fs, iov, iovcnt, offset);
-+    }
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn v9fs_co_preadv(V9fsPDU *pdu, V9fsFidState *fidp,
+     if (v9fs_request_cancelled(pdu)) {
-     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
+         return -EINTR;
      if (ret < 0) {
 diff --git a/block/cloop.c b/block/cloop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/cloop.c
 +++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
          return -EINVAL;
      }
+-    fsdev_co_throttle_request(s->ctx.fst, false, iov, iovcnt);
--    bdrv_set_read_only(bs, true);
++    fsdev_co_throttle_request(s->ctx.fst, THROTTLE_READ, iov, iovcnt);
-+    ret = bdrv_set_read_only(bs, true, errp);
+     v9fs_co_run_in_worker(
-+    if (ret < 0) {
+         {
-+        return ret;
+             err = s->ops->preadv(&s->ctx, &fidp->fs, iov, iovcnt, offset);
 +    }
      /* read header */
      ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
 diff --git a/block/dmg.c b/block/dmg.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/dmg.c
 +++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
          return -EINVAL;
      }
 +    ret = bdrv_set_read_only(bs, true, errp);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
      block_module_load_one("dmg-bz2");
 -    bdrv_set_read_only(bs, true);
      s->n_chunks = 0;
      s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
          goto failed_shutdown;
      }
 +    /* rbd_open is always r/w */
      r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
      if (r < 0) {
          error_setg_errno(errp, -r, "error reading header from %s", s->name);
          goto failed_open;
      }
 -    bdrv_set_read_only(bs, (s->snap != NULL));
 +    /* If we are using an rbd snapshot, we must be r/o, otherwise
 +     * leave as-is */
 +    if (s->snap != NULL) {
 +        r = bdrv_set_read_only(bs, true, &local_err);
 +        if (r < 0) {
 +            error_propagate(errp, local_err);
 +            goto failed_open;
 +        }
 +    }
      qemu_opts_del(opts);
      return 0;
 diff --git a/block/vvfat.c b/block/vvfat.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vvfat.c
 +++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
      s->current_cluster=0xffffffff;
 -    /* read only is the default for safety */
 -    bdrv_set_read_only(bs, true);
      s->qcow = NULL;
      s->qcow_filename = NULL;
      s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
      s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);
      if (qemu_opt_get_bool(opts, "rw", false)) {
 -        ret = enable_write_target(bs, errp);
 +        if (!bdrv_is_read_only(bs)) {
 +            ret = enable_write_target(bs, errp);
 +            if (ret < 0) {
 +                goto fail;
 +            }
 +        } else {
 +            ret = -EPERM;
 +            error_setg(errp,
 +                       "Unable to set VVFAT to 'rw' when drive is read-only");
 +            goto fail;
 +        }
 +    } else  {
 +        /* read only is the default for safety */
 +        ret = bdrv_set_read_only(bs, true, &local_err);
          if (ret < 0) {
 +            error_propagate(errp, local_err);
              goto fail;
          }
 -        bdrv_set_read_only(bs, false);
      }
      bs->total_sectors = cyls * heads * secs;
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                              int64_t sector_num, int nb_sectors, int *pnum);
  bool bdrv_is_read_only(BlockDriverState *bs);
 -void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
 +int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
  bool bdrv_is_sg(BlockDriverState *bs);
  bool bdrv_is_inserted(BlockDriverState *bs);
  int bdrv_media_changed(BlockDriverState *bs);
 --
-.9.3
+.41.0

-New patch
+[PULL 09/14] block/throttle-groups: Use ThrottleDirection instread of bool is_write
+From: zhenwei pi <pizhenwei@bytedance.com>
 'bool is_write' style is obsolete from throttle framework, adapt
 block throttle groups to the new style:
 - use ThrottleDirection instead of 'bool is_write'. Ex,
   schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
   -> schedule_next_request(ThrottleGroupMember *tgm, ThrottleDirection direction)
 - use THROTTLE_MAX instead of hard code. Ex, ThrottleGroupMember *tokens[2]
   -> ThrottleGroupMember *tokens[THROTTLE_MAX]
 - use ThrottleDirection instead of hard code on iteration. Ex, (i = 0; i < 2; i++)
   -> for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++)
 Use a simple python script to test the new style:
  #!/usr/bin/python3
 import subprocess
 import random
 import time
 commands = ['virsh blkdeviotune jammy vda --write-bytes-sec ', \
             'virsh blkdeviotune jammy vda --write-iops-sec ', \
             'virsh blkdeviotune jammy vda --read-bytes-sec ', \
             'virsh blkdeviotune jammy vda --read-iops-sec ']
 for loop in range(1, 1000):
     time.sleep(random.randrange(3, 5))
     command = commands[random.randrange(0, 3)] + str(random.randrange(0, 1000000))
     subprocess.run(command, shell=True, check=True)
 This works fine.
 Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
 Message-Id: <20230728022006.1098509-10-pizhenwei@bytedance.com>
 Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
  include/block/throttle-groups.h |   6 +-
  block/block-backend.c           |   4 +-
  block/throttle-groups.c         | 161 ++++++++++++++++----------------
  block/throttle.c                |   8 +-
 files changed, 90 insertions(+), 89 deletions(-)
 diff --git a/include/block/throttle-groups.h b/include/block/throttle-groups.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/throttle-groups.h
 +++ b/include/block/throttle-groups.h
@@ -XXX,XX +XXX,XX @@ typedef struct ThrottleGroupMember {
      AioContext   *aio_context;
      /* throttled_reqs_lock protects the CoQueues for throttled requests.  */
      CoMutex      throttled_reqs_lock;
 -    CoQueue      throttled_reqs[2];
 +    CoQueue      throttled_reqs[THROTTLE_MAX];
      /* Nonzero if the I/O limits are currently being ignored; generally
       * it is zero.  Accessed with atomic operations.
@@ -XXX,XX +XXX,XX @@ typedef struct ThrottleGroupMember {
       * throttle_state tells us if I/O limits are configured. */
      ThrottleState *throttle_state;
      ThrottleTimers throttle_timers;
 -    unsigned       pending_reqs[2];
 +    unsigned       pending_reqs[THROTTLE_MAX];
      QLIST_ENTRY(ThrottleGroupMember) round_robin;
  } ThrottleGroupMember;
@@ -XXX,XX +XXX,XX @@ void throttle_group_restart_tgm(ThrottleGroupMember *tgm);
  void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm,
                                                          int64_t bytes,
 -                                                        bool is_write);
 +                                                        ThrottleDirection direction);
  void throttle_group_attach_aio_context(ThrottleGroupMember *tgm,
                                         AioContext *new_context);
  void throttle_group_detach_aio_context(ThrottleGroupMember *tgm);
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
      /* throttling disk I/O */
      if (blk->public.throttle_group_member.throttle_state) {
          throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
 -                bytes, false);
 +                bytes, THROTTLE_READ);
      }
      ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
@@ -XXX,XX +XXX,XX @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
      /* throttling disk I/O */
      if (blk->public.throttle_group_member.throttle_state) {
          throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
 -                bytes, true);
 +                bytes, THROTTLE_WRITE);
      }
      if (!blk->enable_write_cache) {
 diff --git a/block/throttle-groups.c b/block/throttle-groups.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/throttle-groups.c
 +++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@
  static void throttle_group_obj_init(Object *obj);
  static void throttle_group_obj_complete(UserCreatable *obj, Error **errp);
 -static void timer_cb(ThrottleGroupMember *tgm, bool is_write);
 +static void timer_cb(ThrottleGroupMember *tgm, ThrottleDirection direction);
  /* The ThrottleGroup structure (with its ThrottleState) is shared
   * among different ThrottleGroupMembers and it's independent from
@@ -XXX,XX +XXX,XX @@ struct ThrottleGroup {
      QemuMutex lock; /* This lock protects the following four fields */
      ThrottleState ts;
      QLIST_HEAD(, ThrottleGroupMember) head;
 -    ThrottleGroupMember *tokens[2];
 -    bool any_timer_armed[2];
 +    ThrottleGroupMember *tokens[THROTTLE_MAX];
 +    bool any_timer_armed[THROTTLE_MAX];
      QEMUClockType clock_type;
      /* This field is protected by the global QEMU mutex */
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *throttle_group_next_tgm(ThrottleGroupMember *tgm)
   * This assumes that tg->lock is held.
   *
   * @tgm:        the ThrottleGroupMember
 - * @is_write:   the type of operation (read/write)
 + * @direction:  the ThrottleDirection
   * @ret:        whether the ThrottleGroupMember has pending requests.
   */
  static inline bool tgm_has_pending_reqs(ThrottleGroupMember *tgm,
 -                                        bool is_write)
 +                                        ThrottleDirection direction)
  {
 -    return tgm->pending_reqs[is_write];
 +    return tgm->pending_reqs[direction];
  }
  /* Return the next ThrottleGroupMember in the round-robin sequence with pending
@@ -XXX,XX +XXX,XX @@ static inline bool tgm_has_pending_reqs(ThrottleGroupMember *tgm,
   * This assumes that tg->lock is held.
   *
   * @tgm:       the current ThrottleGroupMember
 - * @is_write:  the type of operation (read/write)
 + * @direction: the ThrottleDirection
   * @ret:       the next ThrottleGroupMember with pending requests, or tgm if
   *             there is none.
   */
  static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
 -                                                bool is_write)
 +                                                ThrottleDirection direction)
  {
      ThrottleState *ts = tgm->throttle_state;
      ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
       * it's being drained. Skip the round-robin search and return tgm
       * immediately if it has pending requests. Otherwise we could be
       * forcing it to wait for other member's throttled requests. */
 -    if (tgm_has_pending_reqs(tgm, is_write) &&
 +    if (tgm_has_pending_reqs(tgm, direction) &&
          qatomic_read(&tgm->io_limits_disabled)) {
          return tgm;
      }
 -    start = token = tg->tokens[is_write];
 +    start = token = tg->tokens[direction];
      /* get next bs round in round robin style */
      token = throttle_group_next_tgm(token);
 -    while (token != start && !tgm_has_pending_reqs(token, is_write)) {
 +    while (token != start && !tgm_has_pending_reqs(token, direction)) {
          token = throttle_group_next_tgm(token);
      }
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
       * then decide the token is the current tgm because chances are
       * the current tgm got the current request queued.
       */
 -    if (token == start && !tgm_has_pending_reqs(token, is_write)) {
 +    if (token == start && !tgm_has_pending_reqs(token, direction)) {
          token = tgm;
      }
      /* Either we return the original TGM, or one with pending requests */
 -    assert(token == tgm || tgm_has_pending_reqs(token, is_write));
 +    assert(token == tgm || tgm_has_pending_reqs(token, direction));
      return token;
  }
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
   * This assumes that tg->lock is held.
   *
   * @tgm:        the current ThrottleGroupMember
 - * @is_write:   the type of operation (read/write)
 + * @direction:  the ThrottleDirection
   * @ret:        whether the I/O request needs to be throttled or not
   */
  static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
 -                                          bool is_write)
 +                                          ThrottleDirection direction)
  {
      ThrottleState *ts = tgm->throttle_state;
      ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
      ThrottleTimers *tt = &tgm->throttle_timers;
 -    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
      bool must_wait;
      if (qatomic_read(&tgm->io_limits_disabled)) {
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
      }
      /* Check if any of the timers in this group is already armed */
 -    if (tg->any_timer_armed[is_write]) {
 +    if (tg->any_timer_armed[direction]) {
          return true;
      }
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
      /* If a timer just got armed, set tgm as the current token */
      if (must_wait) {
 -        tg->tokens[is_write] = tgm;
 -        tg->any_timer_armed[is_write] = true;
 +        tg->tokens[direction] = tgm;
 +        tg->any_timer_armed[direction] = true;
      }
      return must_wait;
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
   * any request was actually pending.
   *
   * @tgm:       the current ThrottleGroupMember
 - * @is_write:  the type of operation (read/write)
 + * @direction: the ThrottleDirection
   */
  static bool coroutine_fn throttle_group_co_restart_queue(ThrottleGroupMember *tgm,
 -                                                         bool is_write)
 +                                                         ThrottleDirection direction)
  {
      bool ret;
      qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
 -    ret = qemu_co_queue_next(&tgm->throttled_reqs[is_write]);
 +    ret = qemu_co_queue_next(&tgm->throttled_reqs[direction]);
      qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
      return ret;
@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn throttle_group_co_restart_queue(ThrottleGroupMember *tg
   * This assumes that tg->lock is held.
   *
   * @tgm:       the current ThrottleGroupMember
 - * @is_write:  the type of operation (read/write)
 + * @direction: the ThrottleDirection
   */
 -static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
 +static void schedule_next_request(ThrottleGroupMember *tgm,
 +                                  ThrottleDirection direction)
  {
      ThrottleState *ts = tgm->throttle_state;
      ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
@@ -XXX,XX +XXX,XX @@ static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
      ThrottleGroupMember *token;
      /* Check if there's any pending request to schedule next */
 -    token = next_throttle_token(tgm, is_write);
 -    if (!tgm_has_pending_reqs(token, is_write)) {
 +    token = next_throttle_token(tgm, direction);
 +    if (!tgm_has_pending_reqs(token, direction)) {
          return;
      }
      /* Set a timer for the request if it needs to be throttled */
 -    must_wait = throttle_group_schedule_timer(token, is_write);
 +    must_wait = throttle_group_schedule_timer(token, direction);
      /* If it doesn't have to wait, queue it for immediate execution */
      if (!must_wait) {
          /* Give preference to requests from the current tgm */
          if (qemu_in_coroutine() &&
 -            throttle_group_co_restart_queue(tgm, is_write)) {
 +            throttle_group_co_restart_queue(tgm, direction)) {
              token = tgm;
          } else {
              ThrottleTimers *tt = &token->throttle_timers;
              int64_t now = qemu_clock_get_ns(tg->clock_type);
 -            timer_mod(tt->timers[is_write], now);
 -            tg->any_timer_armed[is_write] = true;
 +            timer_mod(tt->timers[direction], now);
 +            tg->any_timer_armed[direction] = true;
          }
 -        tg->tokens[is_write] = token;
 +        tg->tokens[direction] = token;
      }
  }
@@ -XXX,XX +XXX,XX @@ static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
   *
   * @tgm:       the current ThrottleGroupMember
   * @bytes:     the number of bytes for this I/O
 - * @is_write:  the type of operation (read/write)
 + * @direction: the ThrottleDirection
   */
  void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm,
                                                          int64_t bytes,
 -                                                        bool is_write)
 +                                                        ThrottleDirection direction)
  {
      bool must_wait;
      ThrottleGroupMember *token;
      ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
 -    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
      assert(bytes >= 0);
 +    assert(direction < THROTTLE_MAX);
      qemu_mutex_lock(&tg->lock);
      /* First we check if this I/O has to be throttled. */
 -    token = next_throttle_token(tgm, is_write);
 -    must_wait = throttle_group_schedule_timer(token, is_write);
 +    token = next_throttle_token(tgm, direction);
 +    must_wait = throttle_group_schedule_timer(token, direction);
      /* Wait if there's a timer set or queued requests of this type */
 -    if (must_wait || tgm->pending_reqs[is_write]) {
 -        tgm->pending_reqs[is_write]++;
 +    if (must_wait || tgm->pending_reqs[direction]) {
 +        tgm->pending_reqs[direction]++;
          qemu_mutex_unlock(&tg->lock);
          qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
 -        qemu_co_queue_wait(&tgm->throttled_reqs[is_write],
 +        qemu_co_queue_wait(&tgm->throttled_reqs[direction],
                             &tgm->throttled_reqs_lock);
          qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
          qemu_mutex_lock(&tg->lock);
 -        tgm->pending_reqs[is_write]--;
 +        tgm->pending_reqs[direction]--;
      }
      /* The I/O will be executed, so do the accounting */
      throttle_account(tgm->throttle_state, direction, bytes);
      /* Schedule the next request */
 -    schedule_next_request(tgm, is_write);
 +    schedule_next_request(tgm, direction);
      qemu_mutex_unlock(&tg->lock);
  }
  typedef struct {
      ThrottleGroupMember *tgm;
 -    bool is_write;
 +    ThrottleDirection direction;
  } RestartData;
  static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
      ThrottleGroupMember *tgm = data->tgm;
      ThrottleState *ts = tgm->throttle_state;
      ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 -    bool is_write = data->is_write;
 +    ThrottleDirection direction = data->direction;
      bool empty_queue;
 -    empty_queue = !throttle_group_co_restart_queue(tgm, is_write);
 +    empty_queue = !throttle_group_co_restart_queue(tgm, direction);
      /* If the request queue was empty then we have to take care of
       * scheduling the next one */
      if (empty_queue) {
          qemu_mutex_lock(&tg->lock);
 -        schedule_next_request(tgm, is_write);
 +        schedule_next_request(tgm, direction);
          qemu_mutex_unlock(&tg->lock);
      }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
      aio_wait_kick();
  }
 -static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write)
 +static void throttle_group_restart_queue(ThrottleGroupMember *tgm,
 +                                        ThrottleDirection direction)
  {
      Coroutine *co;
      RestartData *rd = g_new0(RestartData, 1);
      rd->tgm = tgm;
 -    rd->is_write = is_write;
 +    rd->direction = direction;
      /* This function is called when a timer is fired or when
       * throttle_group_restart_tgm() is called. Either way, there can
       * be no timer pending on this tgm at this point */
 -    assert(!timer_pending(tgm->throttle_timers.timers[is_write]));
 +    assert(!timer_pending(tgm->throttle_timers.timers[direction]));
      qatomic_inc(&tgm->restart_pending);
@@ -XXX,XX +XXX,XX @@ static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write
  void throttle_group_restart_tgm(ThrottleGroupMember *tgm)
  {
 -    int i;
 +    ThrottleDirection dir;
      if (tgm->throttle_state) {
 -        for (i = 0; i < 2; i++) {
 -            QEMUTimer *t = tgm->throttle_timers.timers[i];
 +        for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
 +            QEMUTimer *t = tgm->throttle_timers.timers[dir];
              if (timer_pending(t)) {
                  /* If there's a pending timer on this tgm, fire it now */
                  timer_del(t);
 -                timer_cb(tgm, i);
 +                timer_cb(tgm, dir);
              } else {
                  /* Else run the next request from the queue manually */
 -                throttle_group_restart_queue(tgm, i);
 +                throttle_group_restart_queue(tgm, dir);
              }
          }
      }
@@ -XXX,XX +XXX,XX @@ void throttle_group_get_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg)
   * because it had been throttled.
   *
   * @tgm:       the ThrottleGroupMember whose request had been throttled
 - * @is_write:  the type of operation (read/write)
 + * @direction: the ThrottleDirection
   */
 -static void timer_cb(ThrottleGroupMember *tgm, bool is_write)
 +static void timer_cb(ThrottleGroupMember *tgm, ThrottleDirection direction)
  {
      ThrottleState *ts = tgm->throttle_state;
      ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
      /* The timer has just been fired, so we can update the flag */
      qemu_mutex_lock(&tg->lock);
 -    tg->any_timer_armed[is_write] = false;
 +    tg->any_timer_armed[direction] = false;
      qemu_mutex_unlock(&tg->lock);
      /* Run the request that was waiting for this timer */
 -    throttle_group_restart_queue(tgm, is_write);
 +    throttle_group_restart_queue(tgm, direction);
  }
  static void read_timer_cb(void *opaque)
  {
 -    timer_cb(opaque, false);
 +    timer_cb(opaque, THROTTLE_READ);
  }
  static void write_timer_cb(void *opaque)
  {
 -    timer_cb(opaque, true);
 +    timer_cb(opaque, THROTTLE_WRITE);
  }
  /* Register a ThrottleGroupMember from the throttling group, also initializing
@@ -XXX,XX +XXX,XX @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm,
                                   const char *groupname,
                                   AioContext *ctx)
  {
 -    int i;
 +    ThrottleDirection dir;
      ThrottleState *ts = throttle_group_incref(groupname);
      ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
@@ -XXX,XX +XXX,XX @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm,
      QEMU_LOCK_GUARD(&tg->lock);
      /* If the ThrottleGroup is new set this ThrottleGroupMember as the token */
 -    for (i = 0; i < 2; i++) {
 -        if (!tg->tokens[i]) {
 -            tg->tokens[i] = tgm;
 +    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
 +        if (!tg->tokens[dir]) {
 +            tg->tokens[dir] = tgm;
          }
 +        qemu_co_queue_init(&tgm->throttled_reqs[dir]);
      }
      QLIST_INSERT_HEAD(&tg->head, tgm, round_robin);
@@ -XXX,XX +XXX,XX @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm,
                           write_timer_cb,
                           tgm);
      qemu_co_mutex_init(&tgm->throttled_reqs_lock);
 -    qemu_co_queue_init(&tgm->throttled_reqs[0]);
 -    qemu_co_queue_init(&tgm->throttled_reqs[1]);
  }
  /* Unregister a ThrottleGroupMember from its group, removing it from the list,
@@ -XXX,XX +XXX,XX @@ void throttle_group_unregister_tgm(ThrottleGroupMember *tgm)
      ThrottleState *ts = tgm->throttle_state;
      ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
      ThrottleGroupMember *token;
 -    int i;
 +    ThrottleDirection dir;
      if (!ts) {
          /* Discard already unregistered tgm */
@@ -XXX,XX +XXX,XX @@ void throttle_group_unregister_tgm(ThrottleGroupMember *tgm)
      AIO_WAIT_WHILE(tgm->aio_context, qatomic_read(&tgm->restart_pending) > 0);
      WITH_QEMU_LOCK_GUARD(&tg->lock) {
 -        for (i = 0; i < 2; i++) {
 -            assert(tgm->pending_reqs[i] == 0);
 -            assert(qemu_co_queue_empty(&tgm->throttled_reqs[i]));
 -            assert(!timer_pending(tgm->throttle_timers.timers[i]));
 -            if (tg->tokens[i] == tgm) {
 +        for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
 +            assert(tgm->pending_reqs[dir] == 0);
 +            assert(qemu_co_queue_empty(&tgm->throttled_reqs[dir]));
 +            assert(!timer_pending(tgm->throttle_timers.timers[dir]));
 +            if (tg->tokens[dir] == tgm) {
                  token = throttle_group_next_tgm(tgm);
                  /* Take care of the case where this is the last tgm in the group */
                  if (token == tgm) {
                      token = NULL;
                  }
 -                tg->tokens[i] = token;
 +                tg->tokens[dir] = token;
              }
          }
@@ -XXX,XX +XXX,XX @@ void throttle_group_detach_aio_context(ThrottleGroupMember *tgm)
  {
      ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
      ThrottleTimers *tt = &tgm->throttle_timers;
 -    int i;
 +    ThrottleDirection dir;
      /* Requests must have been drained */
 -    assert(tgm->pending_reqs[0] == 0 && tgm->pending_reqs[1] == 0);
 -    assert(qemu_co_queue_empty(&tgm->throttled_reqs[0]));
 -    assert(qemu_co_queue_empty(&tgm->throttled_reqs[1]));
 +    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
 +        assert(tgm->pending_reqs[dir] == 0);
 +        assert(qemu_co_queue_empty(&tgm->throttled_reqs[dir]));
 +    }
      /* Kick off next ThrottleGroupMember, if necessary */
      WITH_QEMU_LOCK_GUARD(&tg->lock) {
 -        for (i = 0; i < 2; i++) {
 -            if (timer_pending(tt->timers[i])) {
 -                tg->any_timer_armed[i] = false;
 -                schedule_next_request(tgm, i);
 +        for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
 +            if (timer_pending(tt->timers[dir])) {
 +                tg->any_timer_armed[dir] = false;
 +                schedule_next_request(tgm, dir);
              }
          }
      }
 diff --git a/block/throttle.c b/block/throttle.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/throttle.c
 +++ b/block/throttle.c
@@ -XXX,XX +XXX,XX @@ throttle_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
  {
      ThrottleGroupMember *tgm = bs->opaque;
 -    throttle_group_co_io_limits_intercept(tgm, bytes, false);
 +    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_READ);
      return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
  }
@@ -XXX,XX +XXX,XX @@ throttle_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
                      QEMUIOVector *qiov, BdrvRequestFlags flags)
  {
      ThrottleGroupMember *tgm = bs->opaque;
 -    throttle_group_co_io_limits_intercept(tgm, bytes, true);
 +    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_WRITE);
      return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
  }
@@ -XXX,XX +XXX,XX @@ throttle_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
                            BdrvRequestFlags flags)
  {
      ThrottleGroupMember *tgm = bs->opaque;
 -    throttle_group_co_io_limits_intercept(tgm, bytes, true);
 +    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_WRITE);
      return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn GRAPH_RDLOCK
  throttle_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
  {
      ThrottleGroupMember *tgm = bs->opaque;
 -    throttle_group_co_io_limits_intercept(tgm, bytes, true);
 +    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_WRITE);
      return bdrv_co_pdiscard(bs->file, offset, bytes);
  }
 --
 .41.0

-[Qemu-devel] [PULL 12/12] qemu-iotests: _cleanup_qemu must be called on exit
+[PULL 10/14] file-posix: Clear bs->bl.zoned on error
-For the tests that use the common.qemu functions for running a QEMU
+bs->bl.zoned is what indicates whether the zone information is present
-process, _cleanup_qemu must be called in the exit function.
+and valid; it is the only thing that raw_refresh_zoned_limits() sets if
 CONFIG_BLKZONED is not defined, and it is also the only thing that it
 sets if CONFIG_BLKZONED is defined, but there are no zones.
-If it is not, if the qemu process aborts, then not all of the droppings
+Make sure that it is always set to BLK_Z_NONE if there is an error
-are cleaned up (e.g. pidfile, fifos).
+anywhere in raw_refresh_zoned_limits() so that we do not accidentally
 announce zones while our information is incomplete or invalid.
-This updates those tests that did not have a cleanup in qemu-iotests.
+This also fixes a memory leak in the last error path in
 raw_refresh_zoned_limits().
-(I swapped spaces for tabs in test 102 as well)
+Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 Message-Id: <20230824155345.109765-2-hreitz@redhat.com>
 Reviewed-by: Sam Li <faithilikerun@gmail.com>
 ---
  block/file-posix.c | 21 ++++++++++++---------
 file changed, 12 insertions(+), 9 deletions(-)
-Reported-by: Eric Blake <eblake@redhat.com>
+diff --git a/block/file-posix.c b/block/file-posix.c
-Reviewed-by: Eric Blake <eblake@redhat.com>
+index XXXXXXX..XXXXXXX 100644
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+--- a/block/file-posix.c
-Message-id: d59c2f6ad6c1da8b9b3c7f357c94a7122ccfc55a.1492544096.git.jcody@redhat.com
++++ b/block/file-posix.c
----
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
- tests/qemu-iotests/028 |  1 +
+     BlockZoneModel zoned;
- tests/qemu-iotests/094 | 11 ++++++++---
+     int ret;
- tests/qemu-iotests/102 |  5 +++--
- tests/qemu-iotests/109 |  1 +
+-    bs->bl.zoned = BLK_Z_NONE;
- tests/qemu-iotests/117 |  1 +
+-
- tests/qemu-iotests/130 |  1 +
+     ret = get_sysfs_zoned_model(st, &zoned);
- tests/qemu-iotests/140 |  1 +
+     if (ret < 0 || zoned == BLK_Z_NONE) {
- tests/qemu-iotests/141 |  1 +
+-        return;
- tests/qemu-iotests/143 |  1 +
++        goto no_zoned;
- tests/qemu-iotests/156 |  1 +
+     }
-files changed, 19 insertions(+), 5 deletions(-)
+     bs->bl.zoned = zoned;
-diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
-index XXXXXXX..XXXXXXX 100755
+     if (ret < 0) {
---- a/tests/qemu-iotests/028
+         error_setg_errno(errp, -ret, "Unable to read chunk_sectors "
-+++ b/tests/qemu-iotests/028
+                                      "sysfs attribute");
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
+-        return;
++        goto no_zoned;
- _cleanup()
+     } else if (!ret) {
- {
+         error_setg(errp, "Read 0 from chunk_sectors sysfs attribute");
-+    _cleanup_qemu
+-        return;
-     rm -f "${TEST_IMG}.copy"
++        goto no_zoned;
-     _cleanup_test_img
+     }
      bs->bl.zone_size = ret << BDRV_SECTOR_BITS;
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
      if (ret < 0) {
          error_setg_errno(errp, -ret, "Unable to read nr_zones "
                                       "sysfs attribute");
 -        return;
 +        goto no_zoned;
      } else if (!ret) {
          error_setg(errp, "Read 0 from nr_zones sysfs attribute");
 -        return;
 +        goto no_zoned;
      }
      bs->bl.nr_zones = ret;
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
      ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "report wps failed");
 -        bs->wps = NULL;
 -        return;
 +        goto no_zoned;
      }
      qemu_co_mutex_init(&bs->wps->colock);
 +    return;
 +
 +no_zoned:
 +    bs->bl.zoned = BLK_Z_NONE;
 +    g_free(bs->wps);
 +    bs->wps = NULL;
  }
-diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094
+ #else /* !defined(CONFIG_BLKZONED) */
-index XXXXXXX..XXXXXXX 100755
+ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
 --- a/tests/qemu-iotests/094
 +++ b/tests/qemu-iotests/094
@@ -XXX,XX +XXX,XX @@ echo "QA output created by $seq"
  here="$PWD"
  status=1    # failure is the default!
 -trap "exit \$status" 0 1 2 3 15
 +_cleanup()
 +{
 +    _cleanup_qemu
 +    _cleanup_test_img
 +    rm -f "$TEST_DIR/source.$IMGFMT"
 +}
 +
 +trap "_cleanup; exit \$status" 0 1 2 3 15
  # get standard environment, filters and checks
  . ./common.rc
@@ -XXX,XX +XXX,XX @@ _send_qemu_cmd $QEMU_HANDLE \
  wait=1 _cleanup_qemu
 -_cleanup_test_img
 -rm -f "$TEST_DIR/source.$IMGFMT"
  # success, all done
  echo '*** done'
 diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/102
 +++ b/tests/qemu-iotests/102
@@ -XXX,XX +XXX,XX @@ seq=$(basename $0)
  echo "QA output created by $seq"
  here=$PWD
 -status=1    # failure is the default!
 +status=1    # failure is the default!
  _cleanup()
  {
 -    _cleanup_test_img
 +    _cleanup_qemu
 +    _cleanup_test_img
  }
  trap "_cleanup; exit \$status" 0 1 2 3 15
 diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/109
 +++ b/tests/qemu-iotests/109
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      rm -f $TEST_IMG.src
      _cleanup_test_img
  }
 diff --git a/tests/qemu-iotests/117 b/tests/qemu-iotests/117
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/117
 +++ b/tests/qemu-iotests/117
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      _cleanup_test_img
  }
  trap "_cleanup; exit \$status" 0 1 2 3 15
 diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/130
 +++ b/tests/qemu-iotests/130
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      _cleanup_test_img
  }
  trap "_cleanup; exit \$status" 0 1 2 3 15
 diff --git a/tests/qemu-iotests/140 b/tests/qemu-iotests/140
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/140
 +++ b/tests/qemu-iotests/140
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      _cleanup_test_img
      rm -f "$TEST_DIR/nbd"
  }
 diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/141
 +++ b/tests/qemu-iotests/141
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      _cleanup_test_img
      rm -f "$TEST_DIR/{b,m,o}.$IMGFMT"
  }
 diff --git a/tests/qemu-iotests/143 b/tests/qemu-iotests/143
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/143
 +++ b/tests/qemu-iotests/143
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      rm -f "$TEST_DIR/nbd"
  }
  trap "_cleanup; exit \$status" 0 1 2 3 15
 diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/156
 +++ b/tests/qemu-iotests/156
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      rm -f "$TEST_IMG{,.target}{,.backing,.overlay}"
  }
  trap "_cleanup; exit \$status" 0 1 2 3 15
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 06/12] block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
+[PULL 11/14] file-posix: Check bs->bl.zoned for zone info
-The BDRV_O_ALLOW_RDWR flag allows / prohibits the changing of
+Instead of checking bs->wps or bs->bl.zone_size for whether zone
-the BDS 'read_only' state, but there are a few places where it
+information is present, check bs->bl.zoned.  That is the flag that
-is ignored.  In the bdrv_set_read_only() helper, make sure to
+raw_refresh_zoned_limits() reliably sets to indicate zone support.  If
-honor the flag.
+it is set to something other than BLK_Z_NONE, other values and objects
 like bs->wps and bs->bl.zone_size must be non-null/zero and valid; if it
 is not, we cannot rely on their validity.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20230824155345.109765-3-hreitz@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Sam Li <faithilikerun@gmail.com>
 Message-id: be2e5fb2d285cbece2b6d06bed54a6f56520d251.1491597120.git.jcody@redhat.com
 ---
- block.c | 7 +++++++
+ block/file-posix.c | 12 +++++++-----
-file changed, 7 insertions(+)
+file changed, 7 insertions(+), 5 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/file-posix.c
-+++ b/block.c
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
-         return -EINVAL;
+     if (fd_open(bs) < 0)
          return -EIO;
  #if defined(CONFIG_BLKZONED)
 -    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && bs->wps) {
 +    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
 +        bs->bl.zoned != BLK_Z_NONE) {
          qemu_co_mutex_lock(&bs->wps->colock);
 -        if (type & QEMU_AIO_ZONE_APPEND && bs->bl.zone_size) {
 +        if (type & QEMU_AIO_ZONE_APPEND) {
              int index = offset / bs->bl.zone_size;
              offset = bs->wps->wp[index];
          }
@@ -XXX,XX +XXX,XX @@ out:
  {
      BlockZoneWps *wps = bs->wps;
      if (ret == 0) {
 -        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))
 -            && wps && bs->bl.zone_size) {
 +        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
 +            bs->bl.zoned != BLK_Z_NONE) {
              uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
              if (!BDRV_ZT_IS_CONV(*wp)) {
                  if (type & QEMU_AIO_ZONE_APPEND) {
@@ -XXX,XX +XXX,XX @@ out:
          }
      }
-+    /* Do not clear read_only if it is prohibited */
+-    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && wps) {
-+    if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR)) {
++    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-+        error_setg(errp, "Node '%s' is read only",
++        bs->blk.zoned != BLK_Z_NONE) {
-+                   bdrv_get_device_or_node_name(bs));
+         qemu_co_mutex_unlock(&wps->colock);
-+        return -EPERM;
+     }
 +    }
 +
      bs->read_only = read_only;
      return 0;
  }
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 03/12] qemu-iotests: exclude vxhs from image creation via protocol
+[PULL 12/14] file-posix: Fix zone update in I/O error path
-The protocol VXHS does not support image creation.  Some tests expect
+We must check that zone information is present before running
-to be able to create images through the protocol.  Exclude VXHS from
+update_zones_wp().
 these tests.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=2234374
 Fixes: Coverity CID 1512459
 Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 Message-Id: <20230824155345.109765-4-hreitz@redhat.com>
 Reviewed-by: Sam Li <faithilikerun@gmail.com>
 ---
- tests/qemu-iotests/017 | 1 +
+ block/file-posix.c | 3 ++-
- tests/qemu-iotests/020 | 1 +
+file changed, 2 insertions(+), 1 deletion(-)
  tests/qemu-iotests/029 | 1 +
  tests/qemu-iotests/073 | 1 +
  tests/qemu-iotests/114 | 1 +
  tests/qemu-iotests/130 | 1 +
  tests/qemu-iotests/134 | 1 +
  tests/qemu-iotests/156 | 1 +
  tests/qemu-iotests/158 | 1 +
 files changed, 9 insertions(+)
-diff --git a/tests/qemu-iotests/017 b/tests/qemu-iotests/017
+diff --git a/block/file-posix.c b/block/file-posix.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/017
+--- a/block/file-posix.c
-+++ b/tests/qemu-iotests/017
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ out:
- # Any format supporting backing files
+             }
- _supported_fmt qcow qcow2 vmdk qed
+         }
- _supported_proto generic
+     } else {
-+_unsupported_proto vxhs
+-        if (type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
- _supported_os Linux
++        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
- _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
++            bs->bl.zoned != BLK_Z_NONE) {
+             update_zones_wp(bs, s->fd, 0, 1);
-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 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  # Any format supporting backing files
  _supported_fmt qcow qcow2 vmdk qed
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
  _unsupported_imgopts "subformat=monolithicFlat" \
                       "subformat=twoGbMaxExtentFlat" \
 diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/029
 +++ b/tests/qemu-iotests/029
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  # Any format supporting intenal snapshots
  _supported_fmt qcow2
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
  # Internal snapshots are (currently) impossible with refcount_bits=1
  _unsupported_imgopts 'refcount_bits=1[^0-9]'
 diff --git a/tests/qemu-iotests/073 b/tests/qemu-iotests/073
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/073
 +++ b/tests/qemu-iotests/073
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
  CLUSTER_SIZE=64k
 diff --git a/tests/qemu-iotests/114 b/tests/qemu-iotests/114
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/114
 +++ b/tests/qemu-iotests/114
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
 diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/130
 +++ b/tests/qemu-iotests/130
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
  qemu_comm_method="monitor"
 diff --git a/tests/qemu-iotests/134 b/tests/qemu-iotests/134
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/134
 +++ b/tests/qemu-iotests/134
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
 diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/156
 +++ b/tests/qemu-iotests/156
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2 qed
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
  # Create source disk
 diff --git a/tests/qemu-iotests/158 b/tests/qemu-iotests/158
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/158
 +++ b/tests/qemu-iotests/158
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto generic
 +_unsupported_proto vxhs
  _supported_os Linux
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 02/12] block/vxhs.c: Add qemu-iotests for new block device type "vxhs"
+[PULL 13/14] file-posix: Simplify raw_co_prw's 'out' zone code
-From: Ashish Mittal <ashmit602@gmail.com>
+We duplicate the same condition three times here, pull it out to the top
 level.
-These changes use a vxhs test server that is a part of the following
+Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
-repository:
+Message-Id: <20230824155345.109765-5-hreitz@redhat.com>
-https://github.com/VeritasHyperScale/libqnio.git
+Reviewed-by: Sam Li <faithilikerun@gmail.com>
 ---
  block/file-posix.c | 18 +++++-------------
 file changed, 5 insertions(+), 13 deletions(-)
-Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
+diff --git a/block/file-posix.c b/block/file-posix.c
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Message-id: 1491277689-24949-3-git-send-email-Ashish.Mittal@veritas.com
 ---
  tests/qemu-iotests/common        |  6 ++++++
  tests/qemu-iotests/common.config | 13 +++++++++++++
  tests/qemu-iotests/common.filter |  1 +
  tests/qemu-iotests/common.rc     | 19 +++++++++++++++++++
 files changed, 39 insertions(+)
 diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common
+--- a/block/file-posix.c
-+++ b/tests/qemu-iotests/common
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ check options
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
-     -ssh                test ssh
-     -nfs                test nfs
+ out:
-     -luks               test luks
+ #if defined(CONFIG_BLKZONED)
-+    -vxhs               test vxhs
+-{
-     -xdiff              graphical mode diff
+-    BlockZoneWps *wps = bs->wps;
-     -nocache            use O_DIRECT on backing file
+-    if (ret == 0) {
-     -misalign           misalign memory allocations
+-        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-@@ -XXX,XX +XXX,XX @@ testlist options
+-            bs->bl.zoned != BLK_Z_NONE) {
-             xpand=false
++    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-             ;;
++        bs->bl.zoned != BLK_Z_NONE) {
++        BlockZoneWps *wps = bs->wps;
-+        -vxhs)
++        if (ret == 0) {
-+            IMGPROTO=vxhs
+             uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
-+            xpand=false
+             if (!BDRV_ZT_IS_CONV(*wp)) {
-+            ;;
+                 if (type & QEMU_AIO_ZONE_APPEND) {
-+
+@@ -XXX,XX +XXX,XX @@ out:
-         -ssh)
+                     *wp = offset + bytes;
-             IMGPROTO=ssh
+                 }
-             xpand=false
+             }
-diff --git a/tests/qemu-iotests/common.config b/tests/qemu-iotests/common.config
+-        }
-index XXXXXXX..XXXXXXX 100644
+-    } else {
---- a/tests/qemu-iotests/common.config
+-        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-+++ b/tests/qemu-iotests/common.config
+-            bs->bl.zoned != BLK_Z_NONE) {
-@@ -XXX,XX +XXX,XX @@ if [ -z "$QEMU_NBD_PROG" ]; then
++        } else {
-     export QEMU_NBD_PROG="`set_prog_path qemu-nbd`"
+             update_zones_wp(bs, s->fd, 0, 1);
- fi
+         }
+-    }
-+if [ -z "$QEMU_VXHS_PROG" ]; then
-+    export QEMU_VXHS_PROG="`set_prog_path qnio_server`"
+-    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-+fi
+-        bs->blk.zoned != BLK_Z_NONE) {
-+
+         qemu_co_mutex_unlock(&wps->colock);
- _qemu_wrapper()
+     }
- {
+-}
-     (
+ #endif
-@@ -XXX,XX +XXX,XX @@ _qemu_nbd_wrapper()
+     return ret;
      )
  }
-+_qemu_vxhs_wrapper()
-+{
-+    (
-+        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
-+        exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
-+    )
-+}
-+
- export QEMU=_qemu_wrapper
- export QEMU_IMG=_qemu_img_wrapper
- export QEMU_IO=_qemu_io_wrapper
- export QEMU_NBD=_qemu_nbd_wrapper
-+export QEMU_VXHS=_qemu_vxhs_wrapper
- QEMU_IMG_EXTRA_ARGS=
- if [ "$IMGOPTSSYNTAX" = "true" ]; then
-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_info()
-         -e "s#$TEST_DIR#TEST_DIR#g" \
-         -e "s#$IMGFMT#IMGFMT#g" \
-         -e 's#nbd://127.0.0.1:10810$#TEST_DIR/t.IMGFMT#g' \
-+        -e 's#json.*vdisk-id.*vxhs"}}#TEST_DIR/t.IMGFMT#' \
-         -e "/encrypted: yes/d" \
-         -e "/cluster_size: [0-9]\\+/d" \
-         -e "/table_size: [0-9]\\+/d" \
-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 @@ else
-     elif [ "$IMGPROTO" = "nfs" ]; then
-         TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
-         TEST_IMG=$TEST_DIR/t.$IMGFMT
-+    elif [ "$IMGPROTO" = "vxhs" ]; then
-+        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
-+        TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
-     else
-         TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
-     fi
-@@ -XXX,XX +XXX,XX @@ _make_test_img()
-         eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE >/dev/null &"
-         sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
-     fi
-+
-+    # Start QNIO server on image directory for vxhs protocol
-+    if [ $IMGPROTO = "vxhs" ]; then
-+        eval "$QEMU_VXHS -d  $TEST_DIR > /dev/null &"
-+        sleep 1 # Wait for server to come up.
-+    fi
- }
- _rm_test_img()
-@@ -XXX,XX +XXX,XX @@ _cleanup_test_img()
-             fi
-             rm -f "$TEST_IMG_FILE"
-             ;;
-+        vxhs)
-+            if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
-+                local QEMU_VXHS_PID
-+                read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
-+                kill ${QEMU_VXHS_PID} >/dev/null 2>&1
-+                rm -f "${TEST_DIR}/qemu-vxhs.pid"
-+            fi
-+            rm -f "$TEST_IMG_FILE"
-+            ;;
-+
-         file)
-             _rm_test_img "$TEST_DIR/t.$IMGFMT"
-             _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
 --
-.9.3
+.41.0

-[Qemu-devel] [PULL 01/12] block/vxhs.c: Add support for a new block device type called "vxhs"
+[PULL 14/14] tests/file-io-error: New test
-From: Ashish Mittal <ashmit602@gmail.com>
+This is a regression test for
 https://bugzilla.redhat.com/show_bug.cgi?id=2234374.
-Source code for the qnio library that this code loads can be downloaded from:
+All this test needs to do is trigger an I/O error inside of file-posix
-https://github.com/VeritasHyperScale/libqnio.git
+(specifically raw_co_prw()).  One reliable way to do this without
 requiring special privileges is to use a FUSE export, which allows us to
 inject any error that we want, e.g. via blkdebug.
-Sample command line using JSON syntax:
+Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
-./x86_64-softmmu/qemu-system-x86_64 -name instance-00000008 -S -vnc 0.0.0.0:0
+Message-Id: <20230824155345.109765-6-hreitz@redhat.com>
--k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5
+[hreitz: Fixed test to be skipped when there is no FUSE support, to
--msg timestamp=on
+         suppress fusermount's allow_other warning, and to be skipped
-'json:{"driver":"vxhs","vdisk-id":"c3e9095a-a5ee-4dce-afeb-2a59fb387410",
+         with $IMGOPTSSYNTAX enabled]
-"server":{"host":"172.172.17.4","port":"9999"}}'
+Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
 ---
  tests/qemu-iotests/tests/file-io-error     | 119 +++++++++++++++++++++
  tests/qemu-iotests/tests/file-io-error.out |  33 ++++++
 files changed, 152 insertions(+)
  create mode 100755 tests/qemu-iotests/tests/file-io-error
  create mode 100644 tests/qemu-iotests/tests/file-io-error.out
-Sample command line using URI syntax:
+diff --git a/tests/qemu-iotests/tests/file-io-error b/tests/qemu-iotests/tests/file-io-error
-qemu-img convert -f raw -O raw -n
+new file mode 100755
-/var/lib/nova/instances/_base/0c5eacd5ebea5ed914b6a3e7b18f1ce734c386ad
+index XXXXXXX..XXXXXXX
-vxhs://192.168.0.1:9999/c6718f6b-0401-441d-a8c3-1f0064d75ee0
+--- /dev/null
++++ b/tests/qemu-iotests/tests/file-io-error
-Sample command line using TLS credentials (run in secure mode):
+@@ -XXX,XX +XXX,XX @@
-./qemu-io --object
++#!/usr/bin/env bash
-tls-creds-x509,id=tls0,dir=/etc/pki/qemu/vxhs,endpoint=client -c 'read
++# group: rw
--v 66000 2.5k' 'json:{"server.host": "127.0.0.1", "server.port": "9999",
++#
-"vdisk-id": "/test.raw", "driver": "vxhs", "tls-creds":"tls0"}'
++# Produce an I/O error in file-posix, and hope that it is not catastrophic.
++# Regression test for: https://bugzilla.redhat.com/show_bug.cgi?id=2234374
-Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
++#
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
++# Copyright (C) 2023 Red Hat, Inc.
-Reviewed-by: Jeff Cody <jcody@redhat.com>
++#
-Signed-off-by: Jeff Cody <jcody@redhat.com>
++# This program is free software; you can redistribute it and/or modify
-Message-id: 1491277689-24949-2-git-send-email-Ashish.Mittal@veritas.com
++# it under the terms of the GNU General Public License as published by
----
++# the Free Software Foundation; either version 2 of the License, or
- block/Makefile.objs  |   2 +
++# (at your option) any later version.
- block/trace-events   |  17 ++
++#
- block/vxhs.c         | 575 +++++++++++++++++++++++++++++++++++++++++++++++++++
++# This program is distributed in the hope that it will be useful,
- configure            |  39 ++++
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
- qapi/block-core.json |  23 ++-
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-files changed, 654 insertions(+), 2 deletions(-)
++# GNU General Public License for more details.
- create mode 100644 block/vxhs.c
++#
++# You should have received a copy of the GNU General Public License
-diff --git a/block/Makefile.objs b/block/Makefile.objs
++# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-index XXXXXXX..XXXXXXX 100644
++#
 --- a/block/Makefile.objs
 +++ b/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ block-obj-$(CONFIG_LIBNFS) += nfs.o
  block-obj-$(CONFIG_CURL) += curl.o
  block-obj-$(CONFIG_RBD) += rbd.o
  block-obj-$(CONFIG_GLUSTERFS) += gluster.o
 +block-obj-$(CONFIG_VXHS) += vxhs.o
  block-obj-$(CONFIG_LIBSSH2) += ssh.o
  block-obj-y += accounting.o dirty-bitmap.o
  block-obj-y += write-threshold.o
@@ -XXX,XX +XXX,XX @@ rbd.o-cflags       := $(RBD_CFLAGS)
  rbd.o-libs         := $(RBD_LIBS)
  gluster.o-cflags   := $(GLUSTERFS_CFLAGS)
  gluster.o-libs     := $(GLUSTERFS_LIBS)
 +vxhs.o-libs        := $(VXHS_LIBS)
  ssh.o-cflags       := $(LIBSSH2_CFLAGS)
  ssh.o-libs         := $(LIBSSH2_LIBS)
  block-obj-$(if $(CONFIG_BZIP2),m,n) += dmg-bz2.o
 diff --git a/block/trace-events b/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/block/trace-events
 +++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ qed_aio_write_data(void *s, void *acb, int ret, uint64_t offset, size_t len) "s
  qed_aio_write_prefill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
  qed_aio_write_postfill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
  qed_aio_write_main(void *s, void *acb, int ret, uint64_t offset, size_t len) "s %p acb %p ret %d offset %"PRIu64" len %zu"
 +
-+# block/vxhs.c
++seq=$(basename "$0")
-+vxhs_iio_callback(int error) "ctx is NULL: error %d"
++echo "QA output created by $seq"
-+vxhs_iio_callback_chnfail(int err, int error) "QNIO channel failed, no i/o %d, %d"
++
-+vxhs_iio_callback_unknwn(int opcode, int err) "unexpected opcode %d, errno %d"
++status=1    # failure is the default!
-+vxhs_aio_rw_invalid(int req) "Invalid I/O request iodir %d"
++
-+vxhs_aio_rw_ioerr(char *guid, int iodir, uint64_t size, uint64_t off, void *acb, int ret, int err) "IO ERROR (vDisk %s) FOR : Read/Write = %d size = %lu offset = %lu ACB = %p. Error = %d, errno = %d"
++_cleanup()
-+vxhs_get_vdisk_stat_err(char *guid, int ret, int err) "vDisk (%s) stat ioctl failed, ret = %d, errno = %d"
++{
-+vxhs_get_vdisk_stat(char *vdisk_guid, uint64_t vdisk_size) "vDisk %s stat ioctl returned size %lu"
++    _cleanup_qemu
-+vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %ld"
++    rm -f "$TEST_DIR/fuse-export"
-+vxhs_parse_uri_filename(const char *filename) "URI passed via bdrv_parse_filename %s"
++}
-+vxhs_open_vdiskid(const char *vdisk_id) "Opening vdisk-id %s"
++trap "_cleanup; exit \$status" 0 1 2 3 15
-+vxhs_open_hostinfo(char *of_vsa_addr, int port) "Adding host %s:%d to BDRVVXHSState"
++
-+vxhs_open_iio_open(const char *host) "Failed to connect to storage agent on host %s"
++# get standard environment, filters and checks
-+vxhs_parse_uri_hostinfo(char *host, int port) "Host: IP %s, Port %d"
++. ../common.rc
-+vxhs_close(char *vdisk_guid) "Closing vdisk %s"
++. ../common.filter
-+vxhs_get_creds(const char *cacert, const char *client_key, const char *client_cert) "cacert %s, client_key %s, client_cert %s"
++. ../common.qemu
-diff --git a/block/vxhs.c b/block/vxhs.c
++
 +# Format-agnostic (we do not use any), but we do test the file protocol
 +_supported_proto file
 +_require_drivers blkdebug null-co
 +
 +if [ "$IMGOPTSSYNTAX" = "true" ]; then
 +    # We need `$QEMU_IO -f file` to work; IMGOPTSSYNTAX uses --image-opts,
 +    # breaking -f.
 +    _unsupported_fmt $IMGFMT
 +fi
 +
 +# This is a regression test of a bug in which flie-posix would access zone
 +# information in case of an I/O error even when there is no zone information,
 +# resulting in a division by zero.
 +# To reproduce the problem, we need to trigger an I/O error inside of
 +# file-posix, which can be done (rootless) by providing a FUSE export that
 +# presents only errors when accessed.
 +
 +_launch_qemu
 +_send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'qmp_capabilities'}" \
 +    'return'
 +
 +_send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'blockdev-add',
 +      'arguments': {
 +          'driver': 'blkdebug',
 +          'node-name': 'node0',
 +          'inject-error': [{'event': 'none'}],
 +          'image': {
 +              'driver': 'null-co'
 +          }
 +      }}" \
 +    'return'
 +
 +# FUSE mountpoint must exist and be a regular file
 +touch "$TEST_DIR/fuse-export"
 +
 +# The grep -v to filter fusermount's (benign) error when /etc/fuse.conf does
 +# not contain user_allow_other and the subsequent check for missing FUSE support
 +# have both been taken from iotest 308.
 +output=$(_send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'block-export-add',
 +      'arguments': {
 +          'id': 'exp0',
 +          'type': 'fuse',
 +          'node-name': 'node0',
 +          'mountpoint': '$TEST_DIR/fuse-export',
 +          'writable': true
 +      }}" \
 +    'return' \
 +    | grep -v 'option allow_other only allowed if')
 +
 +if echo "$output" | grep -q "Parameter 'type' does not accept value 'fuse'"; then
 +    _notrun 'No FUSE support'
 +fi
 +echo "$output"
 +
 +echo
 +# This should fail, but gracefully, i.e. just print an I/O error, not crash.
 +$QEMU_IO -f file -c 'write 0 64M' "$TEST_DIR/fuse-export" | _filter_qemu_io
 +echo
 +
 +_send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'block-export-del',
 +      'arguments': {'id': 'exp0'}}" \
 +    'return'
 +
 +_send_qemu_cmd $QEMU_HANDLE \
 +    '' \
 +    'BLOCK_EXPORT_DELETED'
 +
 +_send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'blockdev-del',
 +      'arguments': {'node-name': 'node0'}}" \
 +    'return'
 +
 +# success, all done
 +echo "*** done"
 +rm -f $seq.full
 +status=0
 diff --git a/tests/qemu-iotests/tests/file-io-error.out b/tests/qemu-iotests/tests/file-io-error.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/block/vxhs.c
++++ b/tests/qemu-iotests/tests/file-io-error.out
 @@ -XXX,XX +XXX,XX @@
-+/*
++QA output created by file-io-error
-+ * QEMU Block driver for Veritas HyperScale (VxHS)
++{'execute': 'qmp_capabilities'}
-+ *
++{"return": {}}
-+ * Copyright (c) 2017 Veritas Technologies LLC.
++{'execute': 'blockdev-add',
-+ *
++      'arguments': {
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++          'driver': 'blkdebug',
-+ * See the COPYING file in the top-level directory.
++          'node-name': 'node0',
-+ *
++          'inject-error': [{'event': 'none'}],
-+ */
++          'image': {
 +              'driver': 'null-co'
 +          }
 +      }}
 +{"return": {}}
 +{'execute': 'block-export-add',
 +      'arguments': {
 +          'id': 'exp0',
 +          'type': 'fuse',
 +          'node-name': 'node0',
 +          'mountpoint': 'TEST_DIR/fuse-export',
 +          'writable': true
 +      }}
 +{"return": {}}
 +
-+#include "qemu/osdep.h"
++write failed: Input/output error
 +#include <qnio/qnio_api.h>
 +#include <sys/param.h>
 +#include "block/block_int.h"
 +#include "qapi/qmp/qerror.h"
 +#include "qapi/qmp/qdict.h"
 +#include "qapi/qmp/qstring.h"
 +#include "trace.h"
 +#include "qemu/uri.h"
 +#include "qapi/error.h"
 +#include "qemu/uuid.h"
 +#include "crypto/tlscredsx509.h"
 +
-+#define VXHS_OPT_FILENAME           "filename"
++{'execute': 'block-export-del',
-+#define VXHS_OPT_VDISK_ID           "vdisk-id"
++      'arguments': {'id': 'exp0'}}
-+#define VXHS_OPT_SERVER             "server"
++{"return": {}}
-+#define VXHS_OPT_HOST               "host"
++{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_EXPORT_DELETED", "data": {"id": "exp0"}}
-+#define VXHS_OPT_PORT               "port"
++{'execute': 'blockdev-del',
-+
++      'arguments': {'node-name': 'node0'}}
-+/* Only accessed under QEMU global mutex */
++{"return": {}}
-+static uint32_t vxhs_ref;
++*** done
 +
 +typedef enum {
 +    VDISK_AIO_READ,
 +    VDISK_AIO_WRITE,
 +} VDISKAIOCmd;
 +
 +/*
 + * HyperScale AIO callbacks structure
 + */
 +typedef struct VXHSAIOCB {
 +    BlockAIOCB common;
 +    int err;
 +} VXHSAIOCB;
 +
 +typedef struct VXHSvDiskHostsInfo {
 +    void *dev_handle; /* Device handle */
 +    char *host; /* Host name or IP */
 +    int port; /* Host's port number */
 +} VXHSvDiskHostsInfo;
 +
 +/*
 + * Structure per vDisk maintained for state
 + */
 +typedef struct BDRVVXHSState {
 +    VXHSvDiskHostsInfo vdisk_hostinfo; /* Per host info */
 +    char *vdisk_guid;
 +    char *tlscredsid; /* tlscredsid */
 +} BDRVVXHSState;
 +
 +static void vxhs_complete_aio_bh(void *opaque)
 +{
 +    VXHSAIOCB *acb = opaque;
 +    BlockCompletionFunc *cb = acb->common.cb;
 +    void *cb_opaque = acb->common.opaque;
 +    int ret = 0;
 +
 +    if (acb->err != 0) {
 +        trace_vxhs_complete_aio(acb, acb->err);
 +        ret = (-EIO);
 +    }
 +
 +    qemu_aio_unref(acb);
 +    cb(cb_opaque, ret);
 +}
 +
 +/*
 + * Called from a libqnio thread
 + */
 +static void vxhs_iio_callback(void *ctx, uint32_t opcode, uint32_t error)
 +{
 +    VXHSAIOCB *acb = NULL;
 +
 +    switch (opcode) {
 +    case IRP_READ_REQUEST:
 +    case IRP_WRITE_REQUEST:
 +
 +        /*
 +         * ctx is VXHSAIOCB*
 +         * ctx is NULL if error is QNIOERROR_CHANNEL_HUP
 +         */
 +        if (ctx) {
 +            acb = ctx;
 +        } else {
 +            trace_vxhs_iio_callback(error);
 +            goto out;
 +        }
 +
 +        if (error) {
 +            if (!acb->err) {
 +                acb->err = error;
 +            }
 +            trace_vxhs_iio_callback(error);
 +        }
 +
 +        aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),
 +                                vxhs_complete_aio_bh, acb);
 +        break;
 +
 +    default:
 +        if (error == QNIOERROR_HUP) {
 +            /*
 +             * Channel failed, spontaneous notification,
 +             * not in response to I/O
 +             */
 +            trace_vxhs_iio_callback_chnfail(error, errno);
 +        } else {
 +            trace_vxhs_iio_callback_unknwn(opcode, error);
 +        }
 +        break;
 +    }
 +out:
 +    return;
 +}
 +
 +static QemuOptsList runtime_opts = {
 +    .name = "vxhs",
 +    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
 +    .desc = {
 +        {
 +            .name = VXHS_OPT_FILENAME,
 +            .type = QEMU_OPT_STRING,
 +            .help = "URI to the Veritas HyperScale image",
 +        },
 +        {
 +            .name = VXHS_OPT_VDISK_ID,
 +            .type = QEMU_OPT_STRING,
 +            .help = "UUID of the VxHS vdisk",
 +        },
 +        {
 +            .name = "tls-creds",
 +            .type = QEMU_OPT_STRING,
 +            .help = "ID of the TLS/SSL credentials to use",
 +        },
 +        { /* end of list */ }
 +    },
 +};
 +
 +static QemuOptsList runtime_tcp_opts = {
 +    .name = "vxhs_tcp",
 +    .head = QTAILQ_HEAD_INITIALIZER(runtime_tcp_opts.head),
 +    .desc = {
 +        {
 +            .name = VXHS_OPT_HOST,
 +            .type = QEMU_OPT_STRING,
 +            .help = "host address (ipv4 addresses)",
 +        },
 +        {
 +            .name = VXHS_OPT_PORT,
 +            .type = QEMU_OPT_NUMBER,
 +            .help = "port number on which VxHSD is listening (default 9999)",
 +            .def_value_str = "9999"
 +        },
 +        { /* end of list */ }
 +    },
 +};
 +
 +/*
 + * Parse incoming URI and populate *options with the host
 + * and device information
 + */
 +static int vxhs_parse_uri(const char *filename, QDict *options)
 +{
 +    URI *uri = NULL;
 +    char *port;
 +    int ret = 0;
 +
 +    trace_vxhs_parse_uri_filename(filename);
 +    uri = uri_parse(filename);
 +    if (!uri || !uri->server || !uri->path) {
 +        uri_free(uri);
 +        return -EINVAL;
 +    }
 +
 +    qdict_put(options, VXHS_OPT_SERVER".host", qstring_from_str(uri->server));
 +
 +    if (uri->port) {
 +        port = g_strdup_printf("%d", uri->port);
 +        qdict_put(options, VXHS_OPT_SERVER".port", qstring_from_str(port));
 +        g_free(port);
 +    }
 +
 +    qdict_put(options, "vdisk-id", qstring_from_str(uri->path));
 +
 +    trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);
 +    uri_free(uri);
 +
 +    return ret;
 +}
 +
 +static void vxhs_parse_filename(const char *filename, QDict *options,
 +                                Error **errp)
 +{
 +    if (qdict_haskey(options, "vdisk-id") || qdict_haskey(options, "server")) {
 +        error_setg(errp, "vdisk-id/server and a file name may not be specified "
 +                         "at the same time");
 +        return;
 +    }
 +
 +    if (strstr(filename, "://")) {
 +        int ret = vxhs_parse_uri(filename, options);
 +        if (ret < 0) {
 +            error_setg(errp, "Invalid URI. URI should be of the form "
 +                       "  vxhs://<host_ip>:<port>/<vdisk-id>");
 +        }
 +    }
 +}
 +
 +static int vxhs_init_and_ref(void)
 +{
 +    if (vxhs_ref++ == 0) {
 +        if (iio_init(QNIO_VERSION, vxhs_iio_callback)) {
 +            return -ENODEV;
 +        }
 +    }
 +    return 0;
 +}
 +
 +static void vxhs_unref(void)
 +{
 +    if (--vxhs_ref == 0) {
 +        iio_fini();
 +    }
 +}
 +
 +static void vxhs_get_tls_creds(const char *id, char **cacert,
 +                               char **key, char **cert, Error **errp)
 +{
 +    Object *obj;
 +    QCryptoTLSCreds *creds;
 +    QCryptoTLSCredsX509 *creds_x509;
 +
 +    obj = object_resolve_path_component(
 +        object_get_objects_root(), id);
 +
 +    if (!obj) {
 +        error_setg(errp, "No TLS credentials with id '%s'",
 +                   id);
 +        return;
 +    }
 +
 +    creds_x509 = (QCryptoTLSCredsX509 *)
 +        object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS_X509);
 +
 +    if (!creds_x509) {
 +        error_setg(errp, "Object with id '%s' is not TLS credentials",
 +                   id);
 +        return;
 +    }
 +
 +    creds = &creds_x509->parent_obj;
 +
 +    if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) {
 +        error_setg(errp,
 +                   "Expecting TLS credentials with a client endpoint");
 +        return;
 +    }
 +
 +    /*
 +     * Get the cacert, client_cert and client_key file names.
 +     */
 +    if (!creds->dir) {
 +        error_setg(errp, "TLS object missing 'dir' property value");
 +        return;
 +    }
 +
 +    *cacert = g_strdup_printf("%s/%s", creds->dir,
 +                              QCRYPTO_TLS_CREDS_X509_CA_CERT);
 +    *cert = g_strdup_printf("%s/%s", creds->dir,
 +                            QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
 +    *key = g_strdup_printf("%s/%s", creds->dir,
 +                           QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);
 +}
 +
 +static int vxhs_open(BlockDriverState *bs, QDict *options,
 +                     int bdrv_flags, Error **errp)
 +{
 +    BDRVVXHSState *s = bs->opaque;
 +    void *dev_handlep;
 +    QDict *backing_options = NULL;
 +    QemuOpts *opts = NULL;
 +    QemuOpts *tcp_opts = NULL;
 +    char *of_vsa_addr = NULL;
 +    Error *local_err = NULL;
 +    const char *vdisk_id_opt;
 +    const char *server_host_opt;
 +    int ret = 0;
 +    char *cacert = NULL;
 +    char *client_key = NULL;
 +    char *client_cert = NULL;
 +
 +    ret = vxhs_init_and_ref();
 +    if (ret < 0) {
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    /* Create opts info from runtime_opts and runtime_tcp_opts list */
 +    opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
 +    tcp_opts = qemu_opts_create(&runtime_tcp_opts, NULL, 0, &error_abort);
 +
 +    qemu_opts_absorb_qdict(opts, options, &local_err);
 +    if (local_err) {
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    /* vdisk-id is the disk UUID */
 +    vdisk_id_opt = qemu_opt_get(opts, VXHS_OPT_VDISK_ID);
 +    if (!vdisk_id_opt) {
 +        error_setg(&local_err, QERR_MISSING_PARAMETER, VXHS_OPT_VDISK_ID);
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    /* vdisk-id may contain a leading '/' */
 +    if (strlen(vdisk_id_opt) > UUID_FMT_LEN + 1) {
 +        error_setg(&local_err, "vdisk-id cannot be more than %d characters",
 +                   UUID_FMT_LEN);
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    s->vdisk_guid = g_strdup(vdisk_id_opt);
 +    trace_vxhs_open_vdiskid(vdisk_id_opt);
 +
 +    /* get the 'server.' arguments */
 +    qdict_extract_subqdict(options, &backing_options, VXHS_OPT_SERVER".");
 +
 +    qemu_opts_absorb_qdict(tcp_opts, backing_options, &local_err);
 +    if (local_err != NULL) {
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    server_host_opt = qemu_opt_get(tcp_opts, VXHS_OPT_HOST);
 +    if (!server_host_opt) {
 +        error_setg(&local_err, QERR_MISSING_PARAMETER,
 +                   VXHS_OPT_SERVER"."VXHS_OPT_HOST);
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    if (strlen(server_host_opt) > MAXHOSTNAMELEN) {
 +        error_setg(&local_err, "server.host cannot be more than %d characters",
 +                   MAXHOSTNAMELEN);
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    /* check if we got tls-creds via the --object argument */
 +    s->tlscredsid = g_strdup(qemu_opt_get(opts, "tls-creds"));
 +    if (s->tlscredsid) {
 +        vxhs_get_tls_creds(s->tlscredsid, &cacert, &client_key,
 +                           &client_cert, &local_err);
 +        if (local_err != NULL) {
 +            ret = -EINVAL;
 +            goto out;
 +        }
 +        trace_vxhs_get_creds(cacert, client_key, client_cert);
 +    }
 +
 +    s->vdisk_hostinfo.host = g_strdup(server_host_opt);
 +    s->vdisk_hostinfo.port = g_ascii_strtoll(qemu_opt_get(tcp_opts,
 +                                                          VXHS_OPT_PORT),
 +                                                          NULL, 0);
 +
 +    trace_vxhs_open_hostinfo(s->vdisk_hostinfo.host,
 +                             s->vdisk_hostinfo.port);
 +
 +    of_vsa_addr = g_strdup_printf("of://%s:%d",
 +                                  s->vdisk_hostinfo.host,
 +                                  s->vdisk_hostinfo.port);
 +
 +    /*
 +     * Open qnio channel to storage agent if not opened before
 +     */
 +    dev_handlep = iio_open(of_vsa_addr, s->vdisk_guid, 0,
 +                           cacert, client_key, client_cert);
 +    if (dev_handlep == NULL) {
 +        trace_vxhs_open_iio_open(of_vsa_addr);
 +        ret = -ENODEV;
 +        goto out;
 +    }
 +    s->vdisk_hostinfo.dev_handle = dev_handlep;
 +
 +out:
 +    g_free(of_vsa_addr);
 +    QDECREF(backing_options);
 +    qemu_opts_del(tcp_opts);
 +    qemu_opts_del(opts);
 +    g_free(cacert);
 +    g_free(client_key);
 +    g_free(client_cert);
 +
 +    if (ret < 0) {
 +        vxhs_unref();
 +        error_propagate(errp, local_err);
 +        g_free(s->vdisk_hostinfo.host);
 +        g_free(s->vdisk_guid);
 +        g_free(s->tlscredsid);
 +        s->vdisk_guid = NULL;
 +    }
 +
 +    return ret;
 +}
 +
 +static const AIOCBInfo vxhs_aiocb_info = {
 +    .aiocb_size = sizeof(VXHSAIOCB)
 +};
 +
 +/*
 + * This allocates QEMU-VXHS callback for each IO
 + * and is passed to QNIO. When QNIO completes the work,
 + * it will be passed back through the callback.
 + */
 +static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num,
 +                               QEMUIOVector *qiov, int nb_sectors,
 +                               BlockCompletionFunc *cb, void *opaque,
 +                               VDISKAIOCmd iodir)
 +{
 +    VXHSAIOCB *acb = NULL;
 +    BDRVVXHSState *s = bs->opaque;
 +    size_t size;
 +    uint64_t offset;
 +    int iio_flags = 0;
 +    int ret = 0;
 +    void *dev_handle = s->vdisk_hostinfo.dev_handle;
 +
 +    offset = sector_num * BDRV_SECTOR_SIZE;
 +    size = nb_sectors * BDRV_SECTOR_SIZE;
 +    acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);
 +
 +    /*
 +     * Initialize VXHSAIOCB.
 +     */
 +    acb->err = 0;
 +
 +    iio_flags = IIO_FLAG_ASYNC;
 +
 +    switch (iodir) {
 +    case VDISK_AIO_WRITE:
 +            ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,
 +                             offset, (uint64_t)size, iio_flags);
 +            break;
 +    case VDISK_AIO_READ:
 +            ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,
 +                            offset, (uint64_t)size, iio_flags);
 +            break;
 +    default:
 +            trace_vxhs_aio_rw_invalid(iodir);
 +            goto errout;
 +    }
 +
 +    if (ret != 0) {
 +        trace_vxhs_aio_rw_ioerr(s->vdisk_guid, iodir, size, offset,
 +                                acb, ret, errno);
 +        goto errout;
 +    }
 +    return &acb->common;
 +
 +errout:
 +    qemu_aio_unref(acb);
 +    return NULL;
 +}
 +
 +static BlockAIOCB *vxhs_aio_readv(BlockDriverState *bs,
 +                                   int64_t sector_num, QEMUIOVector *qiov,
 +                                   int nb_sectors,
 +                                   BlockCompletionFunc *cb, void *opaque)
 +{
 +    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
 +                       opaque, VDISK_AIO_READ);
 +}
 +
 +static BlockAIOCB *vxhs_aio_writev(BlockDriverState *bs,
 +                                   int64_t sector_num, QEMUIOVector *qiov,
 +                                   int nb_sectors,
 +                                   BlockCompletionFunc *cb, void *opaque)
 +{
 +    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors,
 +                       cb, opaque, VDISK_AIO_WRITE);
 +}
 +
 +static void vxhs_close(BlockDriverState *bs)
 +{
 +    BDRVVXHSState *s = bs->opaque;
 +
 +    trace_vxhs_close(s->vdisk_guid);
 +
 +    g_free(s->vdisk_guid);
 +    s->vdisk_guid = NULL;
 +
 +    /*
 +     * Close vDisk device
 +     */
 +    if (s->vdisk_hostinfo.dev_handle) {
 +        iio_close(s->vdisk_hostinfo.dev_handle);
 +        s->vdisk_hostinfo.dev_handle = NULL;
 +    }
 +
 +    vxhs_unref();
 +
 +    /*
 +     * Free the dynamically allocated host string etc
 +     */
 +    g_free(s->vdisk_hostinfo.host);
 +    g_free(s->tlscredsid);
 +    s->tlscredsid = NULL;
 +    s->vdisk_hostinfo.host = NULL;
 +    s->vdisk_hostinfo.port = 0;
 +}
 +
 +static int64_t vxhs_get_vdisk_stat(BDRVVXHSState *s)
 +{
 +    int64_t vdisk_size = -1;
 +    int ret = 0;
 +    void *dev_handle = s->vdisk_hostinfo.dev_handle;
 +
 +    ret = iio_ioctl(dev_handle, IOR_VDISK_STAT, &vdisk_size, 0);
 +    if (ret < 0) {
 +        trace_vxhs_get_vdisk_stat_err(s->vdisk_guid, ret, errno);
 +        return -EIO;
 +    }
 +
 +    trace_vxhs_get_vdisk_stat(s->vdisk_guid, vdisk_size);
 +    return vdisk_size;
 +}
 +
 +/*
 + * Returns the size of vDisk in bytes. This is required
 + * by QEMU block upper block layer so that it is visible
 + * to guest.
 + */
 +static int64_t vxhs_getlength(BlockDriverState *bs)
 +{
 +    BDRVVXHSState *s = bs->opaque;
 +    int64_t vdisk_size;
 +
 +    vdisk_size = vxhs_get_vdisk_stat(s);
 +    if (vdisk_size < 0) {
 +        return -EIO;
 +    }
 +
 +    return vdisk_size;
 +}
 +
 +static BlockDriver bdrv_vxhs = {
 +    .format_name                  = "vxhs",
 +    .protocol_name                = "vxhs",
 +    .instance_size                = sizeof(BDRVVXHSState),
 +    .bdrv_file_open               = vxhs_open,
 +    .bdrv_parse_filename          = vxhs_parse_filename,
 +    .bdrv_close                   = vxhs_close,
 +    .bdrv_getlength               = vxhs_getlength,
 +    .bdrv_aio_readv               = vxhs_aio_readv,
 +    .bdrv_aio_writev              = vxhs_aio_writev,
 +};
 +
 +static void bdrv_vxhs_init(void)
 +{
 +    bdrv_register(&bdrv_vxhs);
 +}
 +
 +block_init(bdrv_vxhs_init);
 diff --git a/configure b/configure
 index XXXXXXX..XXXXXXX 100755
 --- a/configure
 +++ b/configure
@@ -XXX,XX +XXX,XX @@ numa=""
  tcmalloc="no"
  jemalloc="no"
  replication="yes"
 +vxhs=""
  supported_cpu="no"
  supported_os="no"
@@ -XXX,XX +XXX,XX @@ for opt do
    ;;
    --enable-replication) replication="yes"
    ;;
 +  --disable-vxhs) vxhs="no"
 +  ;;
 +  --enable-vxhs) vxhs="yes"
 +  ;;
    *)
        echo "ERROR: unknown option $opt"
        echo "Try '$0 --help' for more information"
@@ -XXX,XX +XXX,XX @@ disabled with --disable-FEATURE, default is enabled if available:
    xfsctl          xfsctl support
    qom-cast-debug  cast debugging support
    tools           build qemu-io, qemu-nbd and qemu-image tools
 +  vxhs            Veritas HyperScale vDisk backend support
  NOTE: The object files are built at the place where configure is launched
  EOF
@@ -XXX,XX +XXX,XX @@ if compile_prog "" "" ; then
  fi
  ##########################################
 +# Veritas HyperScale block driver VxHS
 +# Check if libvxhs is installed
 +
 +if test "$vxhs" != "no" ; then
 +  cat > $TMPC <<EOF
 +#include <stdint.h>
 +#include <qnio/qnio_api.h>
 +
 +void *vxhs_callback;
 +
 +int main(void) {
 +    iio_init(QNIO_VERSION, vxhs_callback);
 +    return 0;
 +}
 +EOF
 +  vxhs_libs="-lvxhs -lssl"
 +  if compile_prog "" "$vxhs_libs" ; then
 +    vxhs=yes
 +  else
 +    if test "$vxhs" = "yes" ; then
 +      feature_not_found "vxhs block device" "Install libvxhs See github"
 +    fi
 +    vxhs=no
 +  fi
 +fi
 +
 +##########################################
  # End of CC checks
  # After here, no more $cc or $ld runs
@@ -XXX,XX +XXX,XX @@ echo "tcmalloc support  $tcmalloc"
  echo "jemalloc support  $jemalloc"
  echo "avx2 optimization $avx2_opt"
  echo "replication support $replication"
 +echo "VxHS block device $vxhs"
  if test "$sdl_too_old" = "yes"; then
  echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -XXX,XX +XXX,XX @@ if test "$pthread_setname_np" = "yes" ; then
    echo "CONFIG_PTHREAD_SETNAME_NP=y" >> $config_host_mak
  fi
 +if test "$vxhs" = "yes" ; then
 +  echo "CONFIG_VXHS=y" >> $config_host_mak
 +  echo "VXHS_LIBS=$vxhs_libs" >> $config_host_mak
 +fi
 +
  if test "$tcg_interpreter" = "yes"; then
    QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/tci $QEMU_INCLUDES"
  elif test "$ARCH" = "sparc64" ; then
 diff --git a/qapi/block-core.json b/qapi/block-core.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/block-core.json
 +++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
  #
  # Drivers that are supported in block device operations.
  #
 +# @vxhs: Since 2.10
 +#
  # Since: 2.9
  ##
  { 'enum': 'BlockdevDriver',
@@ -XXX,XX +XXX,XX @@
              'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
              'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed',
              'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh',
 -            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
 +            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
  ##
  # @BlockdevOptionsFile:
@@ -XXX,XX +XXX,XX @@
    'data': { '*offset': 'int', '*size': 'int' } }
  ##
 +# @BlockdevOptionsVxHS:
 +#
 +# Driver specific block device options for VxHS
 +#
 +# @vdisk-id:    UUID of VxHS volume
 +# @server:      vxhs server IP, port
 +# @tls-creds:   TLS credentials ID
 +#
 +# Since: 2.10
 +##
 +{ 'struct': 'BlockdevOptionsVxHS',
 +  'data': { 'vdisk-id': 'str',
 +            'server': 'InetSocketAddressBase',
 +            '*tls-creds': 'str' } }
 +
 +##
  # @BlockdevOptions:
  #
  # Options for creating a block device.  Many options are available for all
@@ -XXX,XX +XXX,XX @@
        'vhdx':       'BlockdevOptionsGenericFormat',
        'vmdk':       'BlockdevOptionsGenericCOWFormat',
        'vpc':        'BlockdevOptionsGenericFormat',
 -      'vvfat':      'BlockdevOptionsVVFAT'
 +      'vvfat':      'BlockdevOptionsVVFAT',
 +      'vxhs':       'BlockdevOptionsVxHS'
    } }
  ##
 --
-.9.3
+.41.0

The following changes since commit bfec359afba088aaacc7d316f43302f28c6e642a:

Merge remote-tracking branch 'remotes/armbru/tags/pull-qdev-2017-04-21' into staging (2017-04-21 11:42:03 +0100)

are available in the git repository at:

git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request

for you to fetch changes up to 1507631e438930bc07f776f303af127a9cdb4d41:

qemu-iotests: _cleanup_qemu must be called on exit (2017-04-21 08:32:44 -0400)

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

Block patches for 2.10

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

Ashish Mittal (2):
  block/vxhs.c: Add support for a new block device type called "vxhs"
  block/vxhs.c: Add qemu-iotests for new block device type "vxhs"

Jeff Cody (10):
  qemu-iotests: exclude vxhs from image creation via protocol
  block: add bdrv_set_read_only() helper function
  block: do not set BDS read_only if copy_on_read enabled
  block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
  block: code movement
  block: introduce bdrv_can_set_read_only()
  block: use bdrv_can_set_read_only() during reopen
  block/rbd - update variable names to more apt names
  block/rbd: Add support for reopen()
  qemu-iotests: _cleanup_qemu must be called on exit

-- 
2.9.3

From: Ashish Mittal <ashmit602@gmail.com>

Source code for the qnio library that this code loads can be downloaded from:
https://github.com/VeritasHyperScale/libqnio.git

Sample command line using JSON syntax:
./x86_64-softmmu/qemu-system-x86_64 -name instance-00000008 -S -vnc 0.0.0.0:0
-k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5
-msg timestamp=on
'json:{"driver":"vxhs","vdisk-id":"c3e9095a-a5ee-4dce-afeb-2a59fb387410",
"server":{"host":"172.172.17.4","port":"9999"}}'

Sample command line using URI syntax:
qemu-img convert -f raw -O raw -n
/var/lib/nova/instances/_base/0c5eacd5ebea5ed914b6a3e7b18f1ce734c386ad
vxhs://192.168.0.1:9999/c6718f6b-0401-441d-a8c3-1f0064d75ee0

Sample command line using TLS credentials (run in secure mode):
./qemu-io --object
tls-creds-x509,id=tls0,dir=/etc/pki/qemu/vxhs,endpoint=client -c 'read
-v 66000 2.5k' 'json:{"server.host": "127.0.0.1", "server.port": "9999",
"vdisk-id": "/test.raw", "driver": "vxhs", "tls-creds":"tls0"}'

Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: 1491277689-24949-2-git-send-email-Ashish.Mittal@veritas.com
---
 block/Makefile.objs  |   2 +
 block/trace-events   |  17 ++
 block/vxhs.c         | 575 +++++++++++++++++++++++++++++++++++++++++++++++++++
 configure            |  39 ++++
 qapi/block-core.json |  23 ++-
 5 files changed, 654 insertions(+), 2 deletions(-)
 create mode 100644 block/vxhs.c

diff --git a/block/Makefile.objs b/block/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ block-obj-$(CONFIG_LIBNFS) += nfs.o
 block-obj-$(CONFIG_CURL) += curl.o
 block-obj-$(CONFIG_RBD) += rbd.o
 block-obj-$(CONFIG_GLUSTERFS) += gluster.o
+block-obj-$(CONFIG_VXHS) += vxhs.o
 block-obj-$(CONFIG_LIBSSH2) += ssh.o
 block-obj-y += accounting.o dirty-bitmap.o
 block-obj-y += write-threshold.o
@@ -XXX,XX +XXX,XX @@ rbd.o-cflags       := $(RBD_CFLAGS)
 rbd.o-libs         := $(RBD_LIBS)
 gluster.o-cflags   := $(GLUSTERFS_CFLAGS)
 gluster.o-libs     := $(GLUSTERFS_LIBS)
+vxhs.o-libs        := $(VXHS_LIBS)
 ssh.o-cflags       := $(LIBSSH2_CFLAGS)
 ssh.o-libs         := $(LIBSSH2_LIBS)
 block-obj-$(if $(CONFIG_BZIP2),m,n) += dmg-bz2.o
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ qed_aio_write_data(void *s, void *acb, int ret, uint64_t offset, size_t len) "s
 qed_aio_write_prefill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
 qed_aio_write_postfill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
 qed_aio_write_main(void *s, void *acb, int ret, uint64_t offset, size_t len) "s %p acb %p ret %d offset %"PRIu64" len %zu"
+
+# block/vxhs.c
+vxhs_iio_callback(int error) "ctx is NULL: error %d"
+vxhs_iio_callback_chnfail(int err, int error) "QNIO channel failed, no i/o %d, %d"
+vxhs_iio_callback_unknwn(int opcode, int err) "unexpected opcode %d, errno %d"
+vxhs_aio_rw_invalid(int req) "Invalid I/O request iodir %d"
+vxhs_aio_rw_ioerr(char *guid, int iodir, uint64_t size, uint64_t off, void *acb, int ret, int err) "IO ERROR (vDisk %s) FOR : Read/Write = %d size = %lu offset = %lu ACB = %p. Error = %d, errno = %d"
+vxhs_get_vdisk_stat_err(char *guid, int ret, int err) "vDisk (%s) stat ioctl failed, ret = %d, errno = %d"
+vxhs_get_vdisk_stat(char *vdisk_guid, uint64_t vdisk_size) "vDisk %s stat ioctl returned size %lu"
+vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %ld"
+vxhs_parse_uri_filename(const char *filename) "URI passed via bdrv_parse_filename %s"
+vxhs_open_vdiskid(const char *vdisk_id) "Opening vdisk-id %s"
+vxhs_open_hostinfo(char *of_vsa_addr, int port) "Adding host %s:%d to BDRVVXHSState"
+vxhs_open_iio_open(const char *host) "Failed to connect to storage agent on host %s"
+vxhs_parse_uri_hostinfo(char *host, int port) "Host: IP %s, Port %d"
+vxhs_close(char *vdisk_guid) "Closing vdisk %s"
+vxhs_get_creds(const char *cacert, const char *client_key, const char *client_cert) "cacert %s, client_key %s, client_cert %s"
diff --git a/block/vxhs.c b/block/vxhs.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/vxhs.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU Block driver for Veritas HyperScale (VxHS)
+ *
+ * Copyright (c) 2017 Veritas Technologies LLC.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include <qnio/qnio_api.h>
+#include <sys/param.h>
+#include "block/block_int.h"
+#include "qapi/qmp/qerror.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qmp/qstring.h"
+#include "trace.h"
+#include "qemu/uri.h"
+#include "qapi/error.h"
+#include "qemu/uuid.h"
+#include "crypto/tlscredsx509.h"
+
+#define VXHS_OPT_FILENAME           "filename"
+#define VXHS_OPT_VDISK_ID           "vdisk-id"
+#define VXHS_OPT_SERVER             "server"
+#define VXHS_OPT_HOST               "host"
+#define VXHS_OPT_PORT               "port"
+
+/* Only accessed under QEMU global mutex */
+static uint32_t vxhs_ref;
+
+typedef enum {
+    VDISK_AIO_READ,
+    VDISK_AIO_WRITE,
+} VDISKAIOCmd;
+
+/*
+ * HyperScale AIO callbacks structure
+ */
+typedef struct VXHSAIOCB {
+    BlockAIOCB common;
+    int err;
+} VXHSAIOCB;
+
+typedef struct VXHSvDiskHostsInfo {
+    void *dev_handle; /* Device handle */
+    char *host; /* Host name or IP */
+    int port; /* Host's port number */
+} VXHSvDiskHostsInfo;
+
+/*
+ * Structure per vDisk maintained for state
+ */
+typedef struct BDRVVXHSState {
+    VXHSvDiskHostsInfo vdisk_hostinfo; /* Per host info */
+    char *vdisk_guid;
+    char *tlscredsid; /* tlscredsid */
+} BDRVVXHSState;
+
+static void vxhs_complete_aio_bh(void *opaque)
+{
+    VXHSAIOCB *acb = opaque;
+    BlockCompletionFunc *cb = acb->common.cb;
+    void *cb_opaque = acb->common.opaque;
+    int ret = 0;
+
+    if (acb->err != 0) {
+        trace_vxhs_complete_aio(acb, acb->err);
+        ret = (-EIO);
+    }
+
+    qemu_aio_unref(acb);
+    cb(cb_opaque, ret);
+}
+
+/*
+ * Called from a libqnio thread
+ */
+static void vxhs_iio_callback(void *ctx, uint32_t opcode, uint32_t error)
+{
+    VXHSAIOCB *acb = NULL;
+
+    switch (opcode) {
+    case IRP_READ_REQUEST:
+    case IRP_WRITE_REQUEST:
+
+        /*
+         * ctx is VXHSAIOCB*
+         * ctx is NULL if error is QNIOERROR_CHANNEL_HUP
+         */
+        if (ctx) {
+            acb = ctx;
+        } else {
+            trace_vxhs_iio_callback(error);
+            goto out;
+        }
+
+        if (error) {
+            if (!acb->err) {
+                acb->err = error;
+            }
+            trace_vxhs_iio_callback(error);
+        }
+
+        aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),
+                                vxhs_complete_aio_bh, acb);
+        break;
+
+    default:
+        if (error == QNIOERROR_HUP) {
+            /*
+             * Channel failed, spontaneous notification,
+             * not in response to I/O
+             */
+            trace_vxhs_iio_callback_chnfail(error, errno);
+        } else {
+            trace_vxhs_iio_callback_unknwn(opcode, error);
+        }
+        break;
+    }
+out:
+    return;
+}
+
+static QemuOptsList runtime_opts = {
+    .name = "vxhs",
+    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
+    .desc = {
+        {
+            .name = VXHS_OPT_FILENAME,
+            .type = QEMU_OPT_STRING,
+            .help = "URI to the Veritas HyperScale image",
+        },
+        {
+            .name = VXHS_OPT_VDISK_ID,
+            .type = QEMU_OPT_STRING,
+            .help = "UUID of the VxHS vdisk",
+        },
+        {
+            .name = "tls-creds",
+            .type = QEMU_OPT_STRING,
+            .help = "ID of the TLS/SSL credentials to use",
+        },
+        { /* end of list */ }
+    },
+};
+
+static QemuOptsList runtime_tcp_opts = {
+    .name = "vxhs_tcp",
+    .head = QTAILQ_HEAD_INITIALIZER(runtime_tcp_opts.head),
+    .desc = {
+        {
+            .name = VXHS_OPT_HOST,
+            .type = QEMU_OPT_STRING,
+            .help = "host address (ipv4 addresses)",
+        },
+        {
+            .name = VXHS_OPT_PORT,
+            .type = QEMU_OPT_NUMBER,
+            .help = "port number on which VxHSD is listening (default 9999)",
+            .def_value_str = "9999"
+        },
+        { /* end of list */ }
+    },
+};
+
+/*
+ * Parse incoming URI and populate *options with the host
+ * and device information
+ */
+static int vxhs_parse_uri(const char *filename, QDict *options)
+{
+    URI *uri = NULL;
+    char *port;
+    int ret = 0;
+
+    trace_vxhs_parse_uri_filename(filename);
+    uri = uri_parse(filename);
+    if (!uri || !uri->server || !uri->path) {
+        uri_free(uri);
+        return -EINVAL;
+    }
+
+    qdict_put(options, VXHS_OPT_SERVER".host", qstring_from_str(uri->server));
+
+    if (uri->port) {
+        port = g_strdup_printf("%d", uri->port);
+        qdict_put(options, VXHS_OPT_SERVER".port", qstring_from_str(port));
+        g_free(port);
+    }
+
+    qdict_put(options, "vdisk-id", qstring_from_str(uri->path));
+
+    trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);
+    uri_free(uri);
+
+    return ret;
+}
+
+static void vxhs_parse_filename(const char *filename, QDict *options,
+                                Error **errp)
+{
+    if (qdict_haskey(options, "vdisk-id") || qdict_haskey(options, "server")) {
+        error_setg(errp, "vdisk-id/server and a file name may not be specified "
+                         "at the same time");
+        return;
+    }
+
+    if (strstr(filename, "://")) {
+        int ret = vxhs_parse_uri(filename, options);
+        if (ret < 0) {
+            error_setg(errp, "Invalid URI. URI should be of the form "
+                       "  vxhs://<host_ip>:<port>/<vdisk-id>");
+        }
+    }
+}
+
+static int vxhs_init_and_ref(void)
+{
+    if (vxhs_ref++ == 0) {
+        if (iio_init(QNIO_VERSION, vxhs_iio_callback)) {
+            return -ENODEV;
+        }
+    }
+    return 0;
+}
+
+static void vxhs_unref(void)
+{
+    if (--vxhs_ref == 0) {
+        iio_fini();
+    }
+}
+
+static void vxhs_get_tls_creds(const char *id, char **cacert,
+                               char **key, char **cert, Error **errp)
+{
+    Object *obj;
+    QCryptoTLSCreds *creds;
+    QCryptoTLSCredsX509 *creds_x509;
+
+    obj = object_resolve_path_component(
+        object_get_objects_root(), id);
+
+    if (!obj) {
+        error_setg(errp, "No TLS credentials with id '%s'",
+                   id);
+        return;
+    }
+
+    creds_x509 = (QCryptoTLSCredsX509 *)
+        object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS_X509);
+
+    if (!creds_x509) {
+        error_setg(errp, "Object with id '%s' is not TLS credentials",
+                   id);
+        return;
+    }
+
+    creds = &creds_x509->parent_obj;
+
+    if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) {
+        error_setg(errp,
+                   "Expecting TLS credentials with a client endpoint");
+        return;
+    }
+
+    /*
+     * Get the cacert, client_cert and client_key file names.
+     */
+    if (!creds->dir) {
+        error_setg(errp, "TLS object missing 'dir' property value");
+        return;
+    }
+
+    *cacert = g_strdup_printf("%s/%s", creds->dir,
+                              QCRYPTO_TLS_CREDS_X509_CA_CERT);
+    *cert = g_strdup_printf("%s/%s", creds->dir,
+                            QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
+    *key = g_strdup_printf("%s/%s", creds->dir,
+                           QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);
+}
+
+static int vxhs_open(BlockDriverState *bs, QDict *options,
+                     int bdrv_flags, Error **errp)
+{
+    BDRVVXHSState *s = bs->opaque;
+    void *dev_handlep;
+    QDict *backing_options = NULL;
+    QemuOpts *opts = NULL;
+    QemuOpts *tcp_opts = NULL;
+    char *of_vsa_addr = NULL;
+    Error *local_err = NULL;
+    const char *vdisk_id_opt;
+    const char *server_host_opt;
+    int ret = 0;
+    char *cacert = NULL;
+    char *client_key = NULL;
+    char *client_cert = NULL;
+
+    ret = vxhs_init_and_ref();
+    if (ret < 0) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* Create opts info from runtime_opts and runtime_tcp_opts list */
+    opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
+    tcp_opts = qemu_opts_create(&runtime_tcp_opts, NULL, 0, &error_abort);
+
+    qemu_opts_absorb_qdict(opts, options, &local_err);
+    if (local_err) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* vdisk-id is the disk UUID */
+    vdisk_id_opt = qemu_opt_get(opts, VXHS_OPT_VDISK_ID);
+    if (!vdisk_id_opt) {
+        error_setg(&local_err, QERR_MISSING_PARAMETER, VXHS_OPT_VDISK_ID);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* vdisk-id may contain a leading '/' */
+    if (strlen(vdisk_id_opt) > UUID_FMT_LEN + 1) {
+        error_setg(&local_err, "vdisk-id cannot be more than %d characters",
+                   UUID_FMT_LEN);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    s->vdisk_guid = g_strdup(vdisk_id_opt);
+    trace_vxhs_open_vdiskid(vdisk_id_opt);
+
+    /* get the 'server.' arguments */
+    qdict_extract_subqdict(options, &backing_options, VXHS_OPT_SERVER".");
+
+    qemu_opts_absorb_qdict(tcp_opts, backing_options, &local_err);
+    if (local_err != NULL) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    server_host_opt = qemu_opt_get(tcp_opts, VXHS_OPT_HOST);
+    if (!server_host_opt) {
+        error_setg(&local_err, QERR_MISSING_PARAMETER,
+                   VXHS_OPT_SERVER"."VXHS_OPT_HOST);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    if (strlen(server_host_opt) > MAXHOSTNAMELEN) {
+        error_setg(&local_err, "server.host cannot be more than %d characters",
+                   MAXHOSTNAMELEN);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* check if we got tls-creds via the --object argument */
+    s->tlscredsid = g_strdup(qemu_opt_get(opts, "tls-creds"));
+    if (s->tlscredsid) {
+        vxhs_get_tls_creds(s->tlscredsid, &cacert, &client_key,
+                           &client_cert, &local_err);
+        if (local_err != NULL) {
+            ret = -EINVAL;
+            goto out;
+        }
+        trace_vxhs_get_creds(cacert, client_key, client_cert);
+    }
+
+    s->vdisk_hostinfo.host = g_strdup(server_host_opt);
+    s->vdisk_hostinfo.port = g_ascii_strtoll(qemu_opt_get(tcp_opts,
+                                                          VXHS_OPT_PORT),
+                                                          NULL, 0);
+
+    trace_vxhs_open_hostinfo(s->vdisk_hostinfo.host,
+                             s->vdisk_hostinfo.port);
+
+    of_vsa_addr = g_strdup_printf("of://%s:%d",
+                                  s->vdisk_hostinfo.host,
+                                  s->vdisk_hostinfo.port);
+
+    /*
+     * Open qnio channel to storage agent if not opened before
+     */
+    dev_handlep = iio_open(of_vsa_addr, s->vdisk_guid, 0,
+                           cacert, client_key, client_cert);
+    if (dev_handlep == NULL) {
+        trace_vxhs_open_iio_open(of_vsa_addr);
+        ret = -ENODEV;
+        goto out;
+    }
+    s->vdisk_hostinfo.dev_handle = dev_handlep;
+
+out:
+    g_free(of_vsa_addr);
+    QDECREF(backing_options);
+    qemu_opts_del(tcp_opts);
+    qemu_opts_del(opts);
+    g_free(cacert);
+    g_free(client_key);
+    g_free(client_cert);
+
+    if (ret < 0) {
+        vxhs_unref();
+        error_propagate(errp, local_err);
+        g_free(s->vdisk_hostinfo.host);
+        g_free(s->vdisk_guid);
+        g_free(s->tlscredsid);
+        s->vdisk_guid = NULL;
+    }
+
+    return ret;
+}
+
+static const AIOCBInfo vxhs_aiocb_info = {
+    .aiocb_size = sizeof(VXHSAIOCB)
+};
+
+/*
+ * This allocates QEMU-VXHS callback for each IO
+ * and is passed to QNIO. When QNIO completes the work,
+ * it will be passed back through the callback.
+ */
+static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num,
+                               QEMUIOVector *qiov, int nb_sectors,
+                               BlockCompletionFunc *cb, void *opaque,
+                               VDISKAIOCmd iodir)
+{
+    VXHSAIOCB *acb = NULL;
+    BDRVVXHSState *s = bs->opaque;
+    size_t size;
+    uint64_t offset;
+    int iio_flags = 0;
+    int ret = 0;
+    void *dev_handle = s->vdisk_hostinfo.dev_handle;
+
+    offset = sector_num * BDRV_SECTOR_SIZE;
+    size = nb_sectors * BDRV_SECTOR_SIZE;
+    acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);
+
+    /*
+     * Initialize VXHSAIOCB.
+     */
+    acb->err = 0;
+
+    iio_flags = IIO_FLAG_ASYNC;
+
+    switch (iodir) {
+    case VDISK_AIO_WRITE:
+            ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,
+                             offset, (uint64_t)size, iio_flags);
+            break;
+    case VDISK_AIO_READ:
+            ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,
+                            offset, (uint64_t)size, iio_flags);
+            break;
+    default:
+            trace_vxhs_aio_rw_invalid(iodir);
+            goto errout;
+    }
+
+    if (ret != 0) {
+        trace_vxhs_aio_rw_ioerr(s->vdisk_guid, iodir, size, offset,
+                                acb, ret, errno);
+        goto errout;
+    }
+    return &acb->common;
+
+errout:
+    qemu_aio_unref(acb);
+    return NULL;
+}
+
+static BlockAIOCB *vxhs_aio_readv(BlockDriverState *bs,
+                                   int64_t sector_num, QEMUIOVector *qiov,
+                                   int nb_sectors,
+                                   BlockCompletionFunc *cb, void *opaque)
+{
+    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
+                       opaque, VDISK_AIO_READ);
+}
+
+static BlockAIOCB *vxhs_aio_writev(BlockDriverState *bs,
+                                   int64_t sector_num, QEMUIOVector *qiov,
+                                   int nb_sectors,
+                                   BlockCompletionFunc *cb, void *opaque)
+{
+    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors,
+                       cb, opaque, VDISK_AIO_WRITE);
+}
+
+static void vxhs_close(BlockDriverState *bs)
+{
+    BDRVVXHSState *s = bs->opaque;
+
+    trace_vxhs_close(s->vdisk_guid);
+
+    g_free(s->vdisk_guid);
+    s->vdisk_guid = NULL;
+
+    /*
+     * Close vDisk device
+     */
+    if (s->vdisk_hostinfo.dev_handle) {
+        iio_close(s->vdisk_hostinfo.dev_handle);
+        s->vdisk_hostinfo.dev_handle = NULL;
+    }
+
+    vxhs_unref();
+
+    /*
+     * Free the dynamically allocated host string etc
+     */
+    g_free(s->vdisk_hostinfo.host);
+    g_free(s->tlscredsid);
+    s->tlscredsid = NULL;
+    s->vdisk_hostinfo.host = NULL;
+    s->vdisk_hostinfo.port = 0;
+}
+
+static int64_t vxhs_get_vdisk_stat(BDRVVXHSState *s)
+{
+    int64_t vdisk_size = -1;
+    int ret = 0;
+    void *dev_handle = s->vdisk_hostinfo.dev_handle;
+
+    ret = iio_ioctl(dev_handle, IOR_VDISK_STAT, &vdisk_size, 0);
+    if (ret < 0) {
+        trace_vxhs_get_vdisk_stat_err(s->vdisk_guid, ret, errno);
+        return -EIO;
+    }
+
+    trace_vxhs_get_vdisk_stat(s->vdisk_guid, vdisk_size);
+    return vdisk_size;
+}
+
+/*
+ * Returns the size of vDisk in bytes. This is required
+ * by QEMU block upper block layer so that it is visible
+ * to guest.
+ */
+static int64_t vxhs_getlength(BlockDriverState *bs)
+{
+    BDRVVXHSState *s = bs->opaque;
+    int64_t vdisk_size;
+
+    vdisk_size = vxhs_get_vdisk_stat(s);
+    if (vdisk_size < 0) {
+        return -EIO;
+    }
+
+    return vdisk_size;
+}
+
+static BlockDriver bdrv_vxhs = {
+    .format_name                  = "vxhs",
+    .protocol_name                = "vxhs",
+    .instance_size                = sizeof(BDRVVXHSState),
+    .bdrv_file_open               = vxhs_open,
+    .bdrv_parse_filename          = vxhs_parse_filename,
+    .bdrv_close                   = vxhs_close,
+    .bdrv_getlength               = vxhs_getlength,
+    .bdrv_aio_readv               = vxhs_aio_readv,
+    .bdrv_aio_writev              = vxhs_aio_writev,
+};
+
+static void bdrv_vxhs_init(void)
+{
+    bdrv_register(&bdrv_vxhs);
+}
+
+block_init(bdrv_vxhs_init);
diff --git a/configure b/configure
index XXXXXXX..XXXXXXX 100755
--- a/configure
+++ b/configure
@@ -XXX,XX +XXX,XX @@ numa=""
 tcmalloc="no"
 jemalloc="no"
 replication="yes"
+vxhs=""
 
 supported_cpu="no"
 supported_os="no"
@@ -XXX,XX +XXX,XX @@ for opt do
   ;;
   --enable-replication) replication="yes"
   ;;
+  --disable-vxhs) vxhs="no"
+  ;;
+  --enable-vxhs) vxhs="yes"
+  ;;
   *)
       echo "ERROR: unknown option $opt"
       echo "Try '$0 --help' for more information"
@@ -XXX,XX +XXX,XX @@ disabled with --disable-FEATURE, default is enabled if available:
   xfsctl          xfsctl support
   qom-cast-debug  cast debugging support
   tools           build qemu-io, qemu-nbd and qemu-image tools
+  vxhs            Veritas HyperScale vDisk backend support
 
 NOTE: The object files are built at the place where configure is launched
 EOF
@@ -XXX,XX +XXX,XX @@ if compile_prog "" "" ; then
 fi
 
 ##########################################
+# Veritas HyperScale block driver VxHS
+# Check if libvxhs is installed
+
+if test "$vxhs" != "no" ; then
+  cat > $TMPC <<EOF
+#include <stdint.h>
+#include <qnio/qnio_api.h>
+
+void *vxhs_callback;
+
+int main(void) {
+    iio_init(QNIO_VERSION, vxhs_callback);
+    return 0;
+}
+EOF
+  vxhs_libs="-lvxhs -lssl"
+  if compile_prog "" "$vxhs_libs" ; then
+    vxhs=yes
+  else
+    if test "$vxhs" = "yes" ; then
+      feature_not_found "vxhs block device" "Install libvxhs See github"
+    fi
+    vxhs=no
+  fi
+fi
+
+##########################################
 # End of CC checks
 # After here, no more $cc or $ld runs
 
@@ -XXX,XX +XXX,XX @@ echo "tcmalloc support  $tcmalloc"
 echo "jemalloc support  $jemalloc"
 echo "avx2 optimization $avx2_opt"
 echo "replication support $replication"
+echo "VxHS block device $vxhs"
 
 if test "$sdl_too_old" = "yes"; then
 echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -XXX,XX +XXX,XX @@ if test "$pthread_setname_np" = "yes" ; then
   echo "CONFIG_PTHREAD_SETNAME_NP=y" >> $config_host_mak
 fi
 
+if test "$vxhs" = "yes" ; then
+  echo "CONFIG_VXHS=y" >> $config_host_mak
+  echo "VXHS_LIBS=$vxhs_libs" >> $config_host_mak
+fi
+
 if test "$tcg_interpreter" = "yes"; then
   QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/tci $QEMU_INCLUDES"
 elif test "$ARCH" = "sparc64" ; then
diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # Drivers that are supported in block device operations.
 #
+# @vxhs: Since 2.10
+#
 # Since: 2.9
 ##
 { 'enum': 'BlockdevDriver',
@@ -XXX,XX +XXX,XX @@
             'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
             'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed',
             'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh',
-            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
+            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
 
 ##
 # @BlockdevOptionsFile:
@@ -XXX,XX +XXX,XX @@
   'data': { '*offset': 'int', '*size': 'int' } }
 
 ##
+# @BlockdevOptionsVxHS:
+#
+# Driver specific block device options for VxHS
+#
+# @vdisk-id:    UUID of VxHS volume
+# @server:      vxhs server IP, port
+# @tls-creds:   TLS credentials ID
+#
+# Since: 2.10
+##
+{ 'struct': 'BlockdevOptionsVxHS',
+  'data': { 'vdisk-id': 'str',
+            'server': 'InetSocketAddressBase',
+            '*tls-creds': 'str' } }
+
+##
 # @BlockdevOptions:
 #
 # Options for creating a block device.  Many options are available for all
@@ -XXX,XX +XXX,XX @@
       'vhdx':       'BlockdevOptionsGenericFormat',
       'vmdk':       'BlockdevOptionsGenericCOWFormat',
       'vpc':        'BlockdevOptionsGenericFormat',
-      'vvfat':      'BlockdevOptionsVVFAT'
+      'vvfat':      'BlockdevOptionsVVFAT',
+      'vxhs':       'BlockdevOptionsVxHS'
   } }
 
 ##
-- 
2.9.3

From: Ashish Mittal <ashmit602@gmail.com>

These changes use a vxhs test server that is a part of the following
repository:
https://github.com/VeritasHyperScale/libqnio.git

Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: 1491277689-24949-3-git-send-email-Ashish.Mittal@veritas.com
---
 tests/qemu-iotests/common        |  6 ++++++
 tests/qemu-iotests/common.config | 13 +++++++++++++
 tests/qemu-iotests/common.filter |  1 +
 tests/qemu-iotests/common.rc     | 19 +++++++++++++++++++
 4 files changed, 39 insertions(+)

diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common
+++ b/tests/qemu-iotests/common
@@ -XXX,XX +XXX,XX @@ check options
     -ssh                test ssh
     -nfs                test nfs
     -luks               test luks
+    -vxhs               test vxhs
     -xdiff              graphical mode diff
     -nocache            use O_DIRECT on backing file
     -misalign           misalign memory allocations
@@ -XXX,XX +XXX,XX @@ testlist options
             xpand=false
             ;;
 
+        -vxhs)
+            IMGPROTO=vxhs
+            xpand=false
+            ;;
+
         -ssh)
             IMGPROTO=ssh
             xpand=false
diff --git a/tests/qemu-iotests/common.config b/tests/qemu-iotests/common.config
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.config
+++ b/tests/qemu-iotests/common.config
@@ -XXX,XX +XXX,XX @@ if [ -z "$QEMU_NBD_PROG" ]; then
     export QEMU_NBD_PROG="`set_prog_path qemu-nbd`"
 fi
 
+if [ -z "$QEMU_VXHS_PROG" ]; then
+    export QEMU_VXHS_PROG="`set_prog_path qnio_server`"
+fi
+
 _qemu_wrapper()
 {
     (
@@ -XXX,XX +XXX,XX @@ _qemu_nbd_wrapper()
     )
 }
 
+_qemu_vxhs_wrapper()
+{
+    (
+        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
+        exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
+    )
+}
+
 export QEMU=_qemu_wrapper
 export QEMU_IMG=_qemu_img_wrapper
 export QEMU_IO=_qemu_io_wrapper
 export QEMU_NBD=_qemu_nbd_wrapper
+export QEMU_VXHS=_qemu_vxhs_wrapper
 
 QEMU_IMG_EXTRA_ARGS=
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
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_info()
         -e "s#$TEST_DIR#TEST_DIR#g" \
         -e "s#$IMGFMT#IMGFMT#g" \
         -e 's#nbd://127.0.0.1:10810$#TEST_DIR/t.IMGFMT#g' \
+        -e 's#json.*vdisk-id.*vxhs"}}#TEST_DIR/t.IMGFMT#' \
         -e "/encrypted: yes/d" \
         -e "/cluster_size: [0-9]\\+/d" \
         -e "/table_size: [0-9]\\+/d" \
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 @@ else
     elif [ "$IMGPROTO" = "nfs" ]; then
         TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
         TEST_IMG=$TEST_DIR/t.$IMGFMT
+    elif [ "$IMGPROTO" = "vxhs" ]; then
+        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
+        TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
     else
         TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
     fi
@@ -XXX,XX +XXX,XX @@ _make_test_img()
         eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE >/dev/null &"
         sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
     fi
+
+    # Start QNIO server on image directory for vxhs protocol
+    if [ $IMGPROTO = "vxhs" ]; then
+        eval "$QEMU_VXHS -d  $TEST_DIR > /dev/null &"
+        sleep 1 # Wait for server to come up.
+    fi
 }
 
 _rm_test_img()
@@ -XXX,XX +XXX,XX @@ _cleanup_test_img()
             fi
             rm -f "$TEST_IMG_FILE"
             ;;
+        vxhs)
+            if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
+                local QEMU_VXHS_PID
+                read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
+                kill ${QEMU_VXHS_PID} >/dev/null 2>&1
+                rm -f "${TEST_DIR}/qemu-vxhs.pid"
+            fi
+            rm -f "$TEST_IMG_FILE"
+            ;;
+
         file)
             _rm_test_img "$TEST_DIR/t.$IMGFMT"
             _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
-- 
2.9.3

The protocol VXHS does not support image creation.  Some tests expect
to be able to create images through the protocol.  Exclude VXHS from
these tests.

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
 # Any format supporting backing files
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
 
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 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Any format supporting backing files
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/029
+++ b/tests/qemu-iotests/029
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Any format supporting intenal snapshots
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 # Internal snapshots are (currently) impossible with refcount_bits=1
 _unsupported_imgopts 'refcount_bits=1[^0-9]'
diff --git a/tests/qemu-iotests/073 b/tests/qemu-iotests/073
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/073
+++ b/tests/qemu-iotests/073
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 CLUSTER_SIZE=64k
diff --git a/tests/qemu-iotests/114 b/tests/qemu-iotests/114
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/114
+++ b/tests/qemu-iotests/114
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 
diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/130
+++ b/tests/qemu-iotests/130
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 qemu_comm_method="monitor"
diff --git a/tests/qemu-iotests/134 b/tests/qemu-iotests/134
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/134
+++ b/tests/qemu-iotests/134
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 
diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/156
+++ b/tests/qemu-iotests/156
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2 qed
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 # Create source disk
diff --git a/tests/qemu-iotests/158 b/tests/qemu-iotests/158
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/158
+++ b/tests/qemu-iotests/158
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 
-- 
2.9.3

We have a helper wrapper for checking for the BDS read_only flag,
add a helper wrapper to set the read_only flag as well.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 9b18972d05f5fa2ac16c014f0af98d680553048d.1491597120.git.jcody@redhat.com
---
 block.c               | 5 +++++
 block/bochs.c         | 2 +-
 block/cloop.c         | 2 +-
 block/dmg.c           | 2 +-
 block/rbd.c           | 2 +-
 block/vvfat.c         | 4 ++--
 include/block/block.h | 1 +
 7 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
     }
 }
 
+void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
+{
+    bs->read_only = read_only;
+}
+
 void bdrv_get_full_backing_filename_from_filename(const char *backed,
                                                   const char *backing,
                                                   char *dest, size_t sz,
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bs->read_only = true; /* no write support yet */
+    bdrv_set_read_only(bs, true); /* no write support yet */
 
     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
     if (ret < 0) {
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bs->read_only = true;
+    bdrv_set_read_only(bs, true);
 
     /* read header */
     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     block_module_load_one("dmg-bz2");
-    bs->read_only = true;
+    bdrv_set_read_only(bs, true);
 
     s->n_chunks = 0;
     s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
         goto failed_open;
     }
 
-    bs->read_only = (s->snap != NULL);
+    bdrv_set_read_only(bs, (s->snap != NULL));
 
     qemu_opts_del(opts);
     return 0;
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
     s->current_cluster=0xffffffff;
 
     /* read only is the default for safety */
-    bs->read_only = true;
+    bdrv_set_read_only(bs, true);
     s->qcow = NULL;
     s->qcow_filename = NULL;
     s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
         if (ret < 0) {
             goto fail;
         }
-        bs->read_only = false;
+        bdrv_set_read_only(bs, false);
     }
 
     bs->total_sectors = cyls * heads * secs;
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                             int64_t sector_num, int nb_sectors, int *pnum);
 
 bool bdrv_is_read_only(BlockDriverState *bs);
+void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
 bool bdrv_is_sg(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
 int bdrv_media_changed(BlockDriverState *bs);
-- 
2.9.3

A few block drivers will set the BDS read_only flag from their
.bdrv_open() function.  This means the bs->read_only flag could
be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ
flag check occurs prior to the call to bdrv->bdrv_open().

This adds an error return to bdrv_set_read_only(), and an error will be
return if we try to set the BDS to read_only while copy_on_read is
enabled.

This patch also changes the behavior of vvfat.  Before, vvfat could
override the drive 'readonly' flag with its own, internal 'rw' flag.

For instance, this -drive parameter would result in a writable image:

"-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"

This is not correct.  Now, attempting to use the above -drive parameter
will result in an error (i.e., 'rw' is incompatible with 'readonly=on').

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 0c5b4c1cc2c651471b131f21376dfd5ea24d2196.1491597120.git.jcody@redhat.com
---
 block.c               | 10 +++++++++-
 block/bochs.c         |  5 ++++-
 block/cloop.c         |  5 ++++-
 block/dmg.c           |  6 +++++-
 block/rbd.c           | 11 ++++++++++-
 block/vvfat.c         | 19 +++++++++++++++----
 include/block/block.h |  2 +-
 7 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
     }
 }
 
-void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 {
+    /* Do not set read_only if copy_on_read is enabled */
+    if (bs->copy_on_read && read_only) {
+        error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
+                   bdrv_get_device_or_node_name(bs));
+        return -EINVAL;
+    }
+
     bs->read_only = read_only;
+    return 0;
 }
 
 void bdrv_get_full_backing_filename_from_filename(const char *backed,
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bdrv_set_read_only(bs, true); /* no write support yet */
+    ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */
+    if (ret < 0) {
+        return ret;
+    }
 
     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
     if (ret < 0) {
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bdrv_set_read_only(bs, true);
+    ret = bdrv_set_read_only(bs, true, errp);
+    if (ret < 0) {
+        return ret;
+    }
 
     /* read header */
     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
+    ret = bdrv_set_read_only(bs, true, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
     block_module_load_one("dmg-bz2");
-    bdrv_set_read_only(bs, true);
 
     s->n_chunks = 0;
     s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
         goto failed_shutdown;
     }
 
+    /* rbd_open is always r/w */
     r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
     if (r < 0) {
         error_setg_errno(errp, -r, "error reading header from %s", s->name);
         goto failed_open;
     }
 
-    bdrv_set_read_only(bs, (s->snap != NULL));
+    /* If we are using an rbd snapshot, we must be r/o, otherwise
+     * leave as-is */
+    if (s->snap != NULL) {
+        r = bdrv_set_read_only(bs, true, &local_err);
+        if (r < 0) {
+            error_propagate(errp, local_err);
+            goto failed_open;
+        }
+    }
 
     qemu_opts_del(opts);
     return 0;
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
 
     s->current_cluster=0xffffffff;
 
-    /* read only is the default for safety */
-    bdrv_set_read_only(bs, true);
     s->qcow = NULL;
     s->qcow_filename = NULL;
     s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
     s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);
 
     if (qemu_opt_get_bool(opts, "rw", false)) {
-        ret = enable_write_target(bs, errp);
+        if (!bdrv_is_read_only(bs)) {
+            ret = enable_write_target(bs, errp);
+            if (ret < 0) {
+                goto fail;
+            }
+        } else {
+            ret = -EPERM;
+            error_setg(errp,
+                       "Unable to set VVFAT to 'rw' when drive is read-only");
+            goto fail;
+        }
+    } else  {
+        /* read only is the default for safety */
+        ret = bdrv_set_read_only(bs, true, &local_err);
         if (ret < 0) {
+            error_propagate(errp, local_err);
             goto fail;
         }
-        bdrv_set_read_only(bs, false);
     }
 
     bs->total_sectors = cyls * heads * secs;
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                             int64_t sector_num, int nb_sectors, int *pnum);
 
 bool bdrv_is_read_only(BlockDriverState *bs);
-void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
 bool bdrv_is_sg(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
 int bdrv_media_changed(BlockDriverState *bs);
-- 
2.9.3

The BDRV_O_ALLOW_RDWR flag allows / prohibits the changing of
the BDS 'read_only' state, but there are a few places where it
is ignored.  In the bdrv_set_read_only() helper, make sure to
honor the flag.

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: be2e5fb2d285cbece2b6d06bed54a6f56520d251.1491597120.git.jcody@redhat.com
---
 block.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
         return -EINVAL;
     }
 
+    /* Do not clear read_only if it is prohibited */
+    if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR)) {
+        error_setg(errp, "Node '%s' is read only",
+                   bdrv_get_device_or_node_name(bs));
+        return -EPERM;
+    }
+
     bs->read_only = read_only;
     return 0;
 }
-- 
2.9.3

Move bdrv_is_read_only() up with its friends.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: 73b2399459760c32506f9407efb9dddb3a2789de.1491597120.git.jcody@redhat.com
---
 block.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
     }
 }
 
+bool bdrv_is_read_only(BlockDriverState *bs)
+{
+    return bs->read_only;
+}
+
 int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 {
     /* Do not set read_only if copy_on_read is enabled */
@@ -XXX,XX +XXX,XX @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
 }
 
-bool bdrv_is_read_only(BlockDriverState *bs)
-{
-    return bs->read_only;
-}
-
 bool bdrv_is_sg(BlockDriverState *bs)
 {
     return bs->sg;
-- 
2.9.3

Introduce check function for setting read_only flags.  Will return < 0 on
error, with appropriate Error value set.  Does not alter any flags.

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: e2bba34ac3bc76a0c42adc390413f358ae0566e8.1491597120.git.jcody@redhat.com
---
 block.c               | 14 +++++++++++++-
 include/block/block.h |  1 +
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ bool bdrv_is_read_only(BlockDriverState *bs)
     return bs->read_only;
 }
 
-int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 {
     /* Do not set read_only if copy_on_read is enabled */
     if (bs->copy_on_read && read_only) {
@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
         return -EPERM;
     }
 
+    return 0;
+}
+
+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+{
+    int ret = 0;
+
+    ret = bdrv_can_set_read_only(bs, read_only, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
     bs->read_only = read_only;
     return 0;
 }
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                             int64_t sector_num, int nb_sectors, int *pnum);
 
 bool bdrv_is_read_only(BlockDriverState *bs);
+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
 int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
 bool bdrv_is_sg(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
-- 
2.9.3

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 00aed7ffdd7be4b9ed9ce1007d50028a72b34ebe.1491597120.git.jcody@redhat.com
---
 block.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
     BlockDriver *drv;
     QemuOpts *opts;
     const char *value;
+    bool read_only;
 
     assert(reopen_state != NULL);
     assert(reopen_state->bs->drv != NULL);
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
         qdict_put(reopen_state->options, "driver", qstring_from_str(value));
     }
 
-    /* if we are to stay read-only, do not allow permission change
-     * to r/w */
-    if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
-        reopen_state->flags & BDRV_O_RDWR) {
-        error_setg(errp, "Node '%s' is read only",
-                   bdrv_get_device_or_node_name(reopen_state->bs));
+    /* If we are to stay read-only, do not allow permission change
+     * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
+     * not set, or if the BDS still has copy_on_read enabled */
+    read_only = !(reopen_state->flags & BDRV_O_RDWR);
+    ret = bdrv_can_set_read_only(reopen_state->bs, read_only, &local_err);
+    if (local_err) {
+        error_propagate(errp, local_err);
         goto error;
     }
 
-- 
2.9.3

Update 'clientname' to be 'user', which tracks better with both
the QAPI and rados variable naming.

Update 'name' to be 'image_name', as it indicates the rbd image.
Naming it 'image' would have been ideal, but we are using that for
the rados_image_t value returned by rbd_open().

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: b7ec1fb2e1cf36f9b6911631447a5b0422590b7d.1491597120.git.jcody@redhat.com
---
 block/rbd.c | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRBDState {
     rados_t cluster;
     rados_ioctx_t io_ctx;
     rbd_image_t image;
-    char *name;
+    char *image_name;
     char *snap;
 } BDRVRBDState;
 
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
     int64_t bytes = 0;
     int64_t objsize;
     int obj_order = 0;
-    const char *pool, *name, *conf, *clientname, *keypairs;
+    const char *pool, *image_name, *conf, *user, *keypairs;
     const char *secretid;
     rados_t cluster;
     rados_ioctx_t io_ctx;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
      */
     pool       = qdict_get_try_str(options, "pool");
     conf       = qdict_get_try_str(options, "conf");
-    clientname = qdict_get_try_str(options, "user");
-    name       = qdict_get_try_str(options, "image");
+    user       = qdict_get_try_str(options, "user");
+    image_name = qdict_get_try_str(options, "image");
     keypairs   = qdict_get_try_str(options, "=keyvalue-pairs");
 
-    ret = rados_create(&cluster, clientname);
+    ret = rados_create(&cluster, user);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "error initializing");
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
         goto shutdown;
     }
 
-    ret = rbd_create(io_ctx, name, bytes, &obj_order);
+    ret = rbd_create(io_ctx, image_name, bytes, &obj_order);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "error rbd create");
     }
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
                          Error **errp)
 {
     BDRVRBDState *s = bs->opaque;
-    const char *pool, *snap, *conf, *clientname, *name, *keypairs;
+    const char *pool, *snap, *conf, *user, *image_name, *keypairs;
     const char *secretid;
     QemuOpts *opts;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     pool           = qemu_opt_get(opts, "pool");
     conf           = qemu_opt_get(opts, "conf");
     snap           = qemu_opt_get(opts, "snapshot");
-    clientname     = qemu_opt_get(opts, "user");
-    name           = qemu_opt_get(opts, "image");
+    user           = qemu_opt_get(opts, "user");
+    image_name     = qemu_opt_get(opts, "image");
     keypairs       = qemu_opt_get(opts, "=keyvalue-pairs");
 
-    if (!pool || !name) {
+    if (!pool || !image_name) {
         error_setg(errp, "Parameters 'pool' and 'image' are required");
         r = -EINVAL;
         goto failed_opts;
     }
 
-    r = rados_create(&s->cluster, clientname);
+    r = rados_create(&s->cluster, user);
     if (r < 0) {
         error_setg_errno(errp, -r, "error initializing");
         goto failed_opts;
     }
 
     s->snap = g_strdup(snap);
-    s->name = g_strdup(name);
+    s->image_name = g_strdup(image_name);
 
     /* try default location when conf=NULL, but ignore failure */
     r = rados_conf_read_file(s->cluster, conf);
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* rbd_open is always r/w */
-    r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
+    r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap);
     if (r < 0) {
-        error_setg_errno(errp, -r, "error reading header from %s", s->name);
+        error_setg_errno(errp, -r, "error reading header from %s",
+                         s->image_name);
         goto failed_open;
     }
 
@@ -XXX,XX +XXX,XX @@ failed_open:
 failed_shutdown:
     rados_shutdown(s->cluster);
     g_free(s->snap);
-    g_free(s->name);
+    g_free(s->image_name);
 failed_opts:
     qemu_opts_del(opts);
     g_free(mon_host);
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_close(BlockDriverState *bs)
     rbd_close(s->image);
     rados_ioctx_destroy(s->io_ctx);
     g_free(s->snap);
-    g_free(s->name);
+    g_free(s->image_name);
     rados_shutdown(s->cluster);
 }
 
-- 
2.9.3

This adds support for reopen in rbd, for changing between r/w and r/o.

Note, that this is only a flag change, but we will block a change from
r/o to r/w if we are using an RBD internal snapshot.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: d4e87539167ec6527d44c97b164eabcccf96e4f3.1491597120.git.jcody@redhat.com
---
 block/rbd.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ failed_opts:
     return r;
 }
 
+
+/* Since RBD is currently always opened R/W via the API,
+ * we just need to check if we are using a snapshot or not, in
+ * order to determine if we will allow it to be R/W */
+static int qemu_rbd_reopen_prepare(BDRVReopenState *state,
+                                   BlockReopenQueue *queue, Error **errp)
+{
+    BDRVRBDState *s = state->bs->opaque;
+    int ret = 0;
+
+    if (s->snap && state->flags & BDRV_O_RDWR) {
+        error_setg(errp,
+                   "Cannot change node '%s' to r/w when using RBD snapshot",
+                   bdrv_get_device_or_node_name(state->bs));
+        ret = -EINVAL;
+    }
+
+    return ret;
+}
+
 static void qemu_rbd_close(BlockDriverState *bs)
 {
     BDRVRBDState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {
     .bdrv_parse_filename    = qemu_rbd_parse_filename,
     .bdrv_file_open         = qemu_rbd_open,
     .bdrv_close             = qemu_rbd_close,
+    .bdrv_reopen_prepare    = qemu_rbd_reopen_prepare,
     .bdrv_create            = qemu_rbd_create,
     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
     .bdrv_get_info          = qemu_rbd_getinfo,
-- 
2.9.3

For the tests that use the common.qemu functions for running a QEMU
process, _cleanup_qemu must be called in the exit function.

If it is not, if the qemu process aborts, then not all of the droppings
are cleaned up (e.g. pidfile, fifos).

This updates those tests that did not have a cleanup in qemu-iotests.

(I swapped spaces for tabs in test 102 as well)

Reported-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: d59c2f6ad6c1da8b9b3c7f357c94a7122ccfc55a.1492544096.git.jcody@redhat.com
---
 tests/qemu-iotests/028 |  1 +
 tests/qemu-iotests/094 | 11 ++++++++---
 tests/qemu-iotests/102 |  5 +++--
 tests/qemu-iotests/109 |  1 +
 tests/qemu-iotests/117 |  1 +
 tests/qemu-iotests/130 |  1 +
 tests/qemu-iotests/140 |  1 +
 tests/qemu-iotests/141 |  1 +
 tests/qemu-iotests/143 |  1 +
 tests/qemu-iotests/156 |  1 +
 10 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/028
+++ b/tests/qemu-iotests/028
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f "${TEST_IMG}.copy"
     _cleanup_test_img
 }
diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/094
+++ b/tests/qemu-iotests/094
@@ -XXX,XX +XXX,XX @@ echo "QA output created by $seq"
 here="$PWD"
 status=1	# failure is the default!
 
-trap "exit \$status" 0 1 2 3 15
+_cleanup()
+{
+    _cleanup_qemu
+    _cleanup_test_img
+    rm -f "$TEST_DIR/source.$IMGFMT"
+}
+
+trap "_cleanup; exit \$status" 0 1 2 3 15
 
 # get standard environment, filters and checks
 . ./common.rc
@@ -XXX,XX +XXX,XX @@ _send_qemu_cmd $QEMU_HANDLE \
 
 wait=1 _cleanup_qemu
 
-_cleanup_test_img
-rm -f "$TEST_DIR/source.$IMGFMT"
 
 # success, all done
 echo '*** done'
diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/102
+++ b/tests/qemu-iotests/102
@@ -XXX,XX +XXX,XX @@ seq=$(basename $0)
 echo "QA output created by $seq"
 
 here=$PWD
-status=1	# failure is the default!
+status=1    # failure is the default!
 
 _cleanup()
 {
-	_cleanup_test_img
+    _cleanup_qemu
+    _cleanup_test_img
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/109
+++ b/tests/qemu-iotests/109
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f $TEST_IMG.src
 	_cleanup_test_img
 }
diff --git a/tests/qemu-iotests/117 b/tests/qemu-iotests/117
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/117
+++ b/tests/qemu-iotests/117
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
 	_cleanup_test_img
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/130
+++ b/tests/qemu-iotests/130
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     _cleanup_test_img
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
diff --git a/tests/qemu-iotests/140 b/tests/qemu-iotests/140
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/140
+++ b/tests/qemu-iotests/140
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     _cleanup_test_img
     rm -f "$TEST_DIR/nbd"
 }
diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/141
+++ b/tests/qemu-iotests/141
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     _cleanup_test_img
     rm -f "$TEST_DIR/{b,m,o}.$IMGFMT"
 }
diff --git a/tests/qemu-iotests/143 b/tests/qemu-iotests/143
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/143
+++ b/tests/qemu-iotests/143
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f "$TEST_DIR/nbd"
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/156
+++ b/tests/qemu-iotests/156
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f "$TEST_IMG{,.target}{,.backing,.overlay}"
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
-- 
2.9.3

The following changes since commit f5fe7c17ac4e309e47e78f0f9761aebc8d2f2c81:

Merge tag 'pull-tcg-20230823-2' of https://gitlab.com/rth7680/qemu into staging (2023-08-28 16:07:04 -0400)

are available in the Git repository at:

https://gitlab.com/hreitz/qemu.git tags/pull-block-2023-09-01

for you to fetch changes up to 380448464dd89291cf7fd7434be6c225482a334d:

tests/file-io-error: New test (2023-08-29 13:01:24 +0200)

----------------------------------------------------------------
Block patches

- Fix for file-posix's zoning code crashing on I/O errors
- Throttling refactoring

----------------------------------------------------------------
Hanna Czenczek (5):
  file-posix: Clear bs->bl.zoned on error
  file-posix: Check bs->bl.zoned for zone info
  file-posix: Fix zone update in I/O error path
  file-posix: Simplify raw_co_prw's 'out' zone code
  tests/file-io-error: New test

Zhenwei Pi (9):
  throttle: introduce enum ThrottleDirection
  test-throttle: use enum ThrottleDirection
  throttle: support read-only and write-only
  test-throttle: test read only and write only
  cryptodev: use NULL throttle timer cb for read direction
  throttle: use enum ThrottleDirection instead of bool is_write
  throttle: use THROTTLE_MAX/ARRAY_SIZE for hard code
  fsdev: Use ThrottleDirection instread of bool is_write
  block/throttle-groups: Use ThrottleDirection instread of bool is_write

fsdev/qemu-fsdev-throttle.h                |   4 +-
 include/block/throttle-groups.h            |   6 +-
 include/qemu/throttle.h                    |  16 +-
 backends/cryptodev.c                       |  12 +-
 block/block-backend.c                      |   4 +-
 block/file-posix.c                         |  42 +++---
 block/throttle-groups.c                    | 163 +++++++++++----------
 block/throttle.c                           |   8 +-
 fsdev/qemu-fsdev-throttle.c                |  18 ++-
 hw/9pfs/cofile.c                           |   4 +-
 tests/unit/test-throttle.c                 |  76 +++++++++-
 util/throttle.c                            |  84 +++++++----
 tests/qemu-iotests/tests/file-io-error     | 119 +++++++++++++++
 tests/qemu-iotests/tests/file-io-error.out |  33 +++++
 14 files changed, 418 insertions(+), 171 deletions(-)
 create mode 100755 tests/qemu-iotests/tests/file-io-error
 create mode 100644 tests/qemu-iotests/tests/file-io-error.out

-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

Use enum ThrottleDirection instead of number index.

Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-2-pizhenwei@bytedance.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 include/qemu/throttle.h | 11 ++++++++---
 util/throttle.c         | 16 +++++++++-------
 2 files changed, 17 insertions(+), 10 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 struct ThrottleState {
     int64_t previous_leak;    /* timestamp of the last leak done */
 } ThrottleState;
 
+typedef enum {
+    THROTTLE_READ = 0,
+    THROTTLE_WRITE,
+    THROTTLE_MAX
+} ThrottleDirection;
+
 typedef struct ThrottleTimers {
-    QEMUTimer *timers[2];     /* timers used to do the throttling */
+    QEMUTimer *timers[THROTTLE_MAX];    /* timers used to do the throttling */
     QEMUClockType clock_type; /* the clock used */
 
     /* Callbacks */
-    QEMUTimerCB *read_timer_cb;
-    QEMUTimerCB *write_timer_cb;
+    QEMUTimerCB *timer_cb[THROTTLE_MAX];
     void *timer_opaque;
 } ThrottleTimers;
 
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 bool throttle_compute_timer(ThrottleState *ts,
 void throttle_timers_attach_aio_context(ThrottleTimers *tt,
                                         AioContext *new_context)
 {
-    tt->timers[0] = aio_timer_new(new_context, tt->clock_type, SCALE_NS,
-                                  tt->read_timer_cb, tt->timer_opaque);
-    tt->timers[1] = aio_timer_new(new_context, tt->clock_type, SCALE_NS,
-                                  tt->write_timer_cb, tt->timer_opaque);
+    tt->timers[THROTTLE_READ] =
+        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
+                      tt->timer_cb[THROTTLE_READ], tt->timer_opaque);
+    tt->timers[THROTTLE_WRITE] =
+        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
+                      tt->timer_cb[THROTTLE_WRITE], tt->timer_opaque);
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ void throttle_timers_init(ThrottleTimers *tt,
     memset(tt, 0, sizeof(ThrottleTimers));
 
     tt->clock_type = clock_type;
-    tt->read_timer_cb = read_timer_cb;
-    tt->write_timer_cb = write_timer_cb;
+    tt->timer_cb[THROTTLE_READ] = read_timer_cb;
+    tt->timer_cb[THROTTLE_WRITE] = write_timer_cb;
     tt->timer_opaque = timer_opaque;
     throttle_timers_attach_aio_context(tt, aio_context);
 }
@@ -XXX,XX +XXX,XX @@ void throttle_timers_detach_aio_context(ThrottleTimers *tt)
 {
     int i;
 
-    for (i = 0; i < 2; i++) {
+    for (i = 0; i < THROTTLE_MAX; i++) {
         throttle_timer_destroy(&tt->timers[i]);
     }
 }
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

Use enum ThrottleDirection instead in the throttle test codes.

Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-3-pizhenwei@bytedance.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 tests/unit/test-throttle.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/unit/test-throttle.c b/tests/unit/test-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-throttle.c
+++ b/tests/unit/test-throttle.c
@@ -XXX,XX +XXX,XX @@ static void test_init(void)
 
     /* check initialized fields */
     g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
-    g_assert(tt->timers[0]);
-    g_assert(tt->timers[1]);
+    g_assert(tt->timers[THROTTLE_READ]);
+    g_assert(tt->timers[THROTTLE_WRITE]);
 
     /* check other fields where cleared */
     g_assert(!ts.previous_leak);
@@ -XXX,XX +XXX,XX @@ static void test_destroy(void)
     throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
                          read_timer_cb, write_timer_cb, &ts);
     throttle_timers_destroy(tt);
-    for (i = 0; i < 2; i++) {
+    for (i = 0; i < THROTTLE_MAX; i++) {
         g_assert(!tt->timers[i]);
     }
 }
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

Only one direction is necessary in several scenarios:
- a read-only disk
- operations on a device are considered as *write* only. For example,
  encrypt/decrypt/sign/verify operations on a cryptodev use a single
  *write* timer(read timer callback is defined, but never invoked).

Allow a single direction in throttle, this reduces memory, and uplayer
does not need a dummy callback any more.

Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-4-pizhenwei@bytedance.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 util/throttle.c | 42 ++++++++++++++++++++++++++++--------------
 1 file changed, 28 insertions(+), 14 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 bool throttle_compute_timer(ThrottleState *ts,
 void throttle_timers_attach_aio_context(ThrottleTimers *tt,
                                         AioContext *new_context)
 {
-    tt->timers[THROTTLE_READ] =
-        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
-                      tt->timer_cb[THROTTLE_READ], tt->timer_opaque);
-    tt->timers[THROTTLE_WRITE] =
-        aio_timer_new(new_context, tt->clock_type, SCALE_NS,
-                      tt->timer_cb[THROTTLE_WRITE], tt->timer_opaque);
+    ThrottleDirection dir;
+
+    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+        if (tt->timer_cb[dir]) {
+            tt->timers[dir] =
+                aio_timer_new(new_context, tt->clock_type, SCALE_NS,
+                              tt->timer_cb[dir], tt->timer_opaque);
+        }
+    }
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ void throttle_timers_init(ThrottleTimers *tt,
                           QEMUTimerCB *write_timer_cb,
                           void *timer_opaque)
 {
+    assert(read_timer_cb || write_timer_cb);
     memset(tt, 0, sizeof(ThrottleTimers));
 
     tt->clock_type = clock_type;
@@ -XXX,XX +XXX,XX @@ void throttle_timers_init(ThrottleTimers *tt,
 /* destroy a timer */
 static void throttle_timer_destroy(QEMUTimer **timer)
 {
-    assert(*timer != NULL);
+    if (*timer == NULL) {
+        return;
+    }
 
     timer_free(*timer);
     *timer = NULL;
@@ -XXX,XX +XXX,XX @@ static void throttle_timer_destroy(QEMUTimer **timer)
 /* Remove timers from event loop */
 void throttle_timers_detach_aio_context(ThrottleTimers *tt)
 {
-    int i;
+    ThrottleDirection dir;
 
-    for (i = 0; i < THROTTLE_MAX; i++) {
-        throttle_timer_destroy(&tt->timers[i]);
+    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+        throttle_timer_destroy(&tt->timers[dir]);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ void throttle_timers_destroy(ThrottleTimers *tt)
 /* is any throttling timer configured */
 bool throttle_timers_are_initialized(ThrottleTimers *tt)
 {
-    if (tt->timers[0]) {
-        return true;
+    ThrottleDirection dir;
+
+    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+        if (tt->timers[dir]) {
+            return true;
+        }
     }
 
     return false;
@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
 {
     int64_t now = qemu_clock_get_ns(tt->clock_type);
     int64_t next_timestamp;
+    QEMUTimer *timer;
     bool must_wait;
 
+    timer = is_write ? tt->timers[THROTTLE_WRITE] : tt->timers[THROTTLE_READ];
+    assert(timer);
+
     must_wait = throttle_compute_timer(ts,
                                        is_write,
                                        now,
@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
     }
 
     /* request throttled and timer pending -> do nothing */
-    if (timer_pending(tt->timers[is_write])) {
+    if (timer_pending(timer)) {
         return true;
     }
 
     /* request throttled and timer not pending -> arm timer */
-    timer_mod(tt->timers[is_write], next_timestamp);
+    timer_mod(timer, next_timestamp);
     return true;
 }
 
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-5-pizhenwei@bytedance.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 tests/unit/test-throttle.c | 66 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/tests/unit/test-throttle.c b/tests/unit/test-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-throttle.c
+++ b/tests/unit/test-throttle.c
@@ -XXX,XX +XXX,XX @@ static void test_init(void)
     throttle_timers_destroy(tt);
 }
 
+static void test_init_readonly(void)
+{
+    int i;
+
+    tt = &tgm.throttle_timers;
+
+    /* fill the structures with crap */
+    memset(&ts, 1, sizeof(ts));
+    memset(tt, 1, sizeof(*tt));
+
+    /* init structures */
+    throttle_init(&ts);
+    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
+                         read_timer_cb, NULL, &ts);
+
+    /* check initialized fields */
+    g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
+    g_assert(tt->timers[THROTTLE_READ]);
+    g_assert(!tt->timers[THROTTLE_WRITE]);
+
+    /* check other fields where cleared */
+    g_assert(!ts.previous_leak);
+    g_assert(!ts.cfg.op_size);
+    for (i = 0; i < BUCKETS_COUNT; i++) {
+        g_assert(!ts.cfg.buckets[i].avg);
+        g_assert(!ts.cfg.buckets[i].max);
+        g_assert(!ts.cfg.buckets[i].level);
+    }
+
+    throttle_timers_destroy(tt);
+}
+
+static void test_init_writeonly(void)
+{
+    int i;
+
+    tt = &tgm.throttle_timers;
+
+    /* fill the structures with crap */
+    memset(&ts, 1, sizeof(ts));
+    memset(tt, 1, sizeof(*tt));
+
+    /* init structures */
+    throttle_init(&ts);
+    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
+                         NULL, write_timer_cb, &ts);
+
+    /* check initialized fields */
+    g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
+    g_assert(!tt->timers[THROTTLE_READ]);
+    g_assert(tt->timers[THROTTLE_WRITE]);
+
+    /* check other fields where cleared */
+    g_assert(!ts.previous_leak);
+    g_assert(!ts.cfg.op_size);
+    for (i = 0; i < BUCKETS_COUNT; i++) {
+        g_assert(!ts.cfg.buckets[i].avg);
+        g_assert(!ts.cfg.buckets[i].max);
+        g_assert(!ts.cfg.buckets[i].level);
+    }
+
+    throttle_timers_destroy(tt);
+}
+
 static void test_destroy(void)
 {
     int i;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/throttle/leak_bucket",        test_leak_bucket);
     g_test_add_func("/throttle/compute_wait",       test_compute_wait);
     g_test_add_func("/throttle/init",               test_init);
+    g_test_add_func("/throttle/init_readonly",      test_init_readonly);
+    g_test_add_func("/throttle/init_writeonly",     test_init_writeonly);
     g_test_add_func("/throttle/destroy",            test_destroy);
     g_test_add_func("/throttle/have_timer",         test_have_timer);
     g_test_add_func("/throttle/detach_attach",      test_detach_attach);
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

Operations on a cryptodev are considered as *write* only, the callback
of read direction is never invoked. Use NULL instead of an unreachable
path(cryptodev_backend_throttle_timer_cb on read direction).

The dummy read timer(never invoked) is already removed here, it means
that the 'FIXME' tag is no longer needed.

Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-6-pizhenwei@bytedance.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 backends/cryptodev.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/backends/cryptodev.c b/backends/cryptodev.c
index XXXXXXX..XXXXXXX 100644
--- a/backends/cryptodev.c
+++ b/backends/cryptodev.c
@@ -XXX,XX +XXX,XX @@ static void cryptodev_backend_set_throttle(CryptoDevBackend *backend, int field,
     if (!enabled) {
         throttle_init(&backend->ts);
         throttle_timers_init(&backend->tt, qemu_get_aio_context(),
-                             QEMU_CLOCK_REALTIME,
-                             cryptodev_backend_throttle_timer_cb, /* FIXME */
+                             QEMU_CLOCK_REALTIME, NULL,
                              cryptodev_backend_throttle_timer_cb, backend);
     }
 
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

enum ThrottleDirection is already there, use ThrottleDirection instead
of 'bool is_write' for throttle API, also modify related codes from
block, fsdev, cryptodev and tests.

Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-7-pizhenwei@bytedance.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 include/qemu/throttle.h     |  5 +++--
 backends/cryptodev.c        |  9 +++++----
 block/throttle-groups.c     |  6 ++++--
 fsdev/qemu-fsdev-throttle.c |  8 +++++---
 tests/unit/test-throttle.c  |  4 ++--
 util/throttle.c             | 31 +++++++++++++++++--------------
 6 files changed, 36 insertions(+), 27 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 @@ void throttle_config_init(ThrottleConfig *cfg);
 /* usage */
 bool throttle_schedule_timer(ThrottleState *ts,
                              ThrottleTimers *tt,
-                             bool is_write);
+                             ThrottleDirection direction);
 
-void throttle_account(ThrottleState *ts, bool is_write, uint64_t size);
+void throttle_account(ThrottleState *ts, ThrottleDirection direction,
+                      uint64_t size);
 void throttle_limits_to_config(ThrottleLimits *arg, ThrottleConfig *cfg,
                                Error **errp);
 void throttle_config_to_limits(ThrottleConfig *cfg, ThrottleLimits *var);
diff --git a/backends/cryptodev.c b/backends/cryptodev.c
index XXXXXXX..XXXXXXX 100644
--- a/backends/cryptodev.c
+++ b/backends/cryptodev.c
@@ -XXX,XX +XXX,XX @@ static void cryptodev_backend_throttle_timer_cb(void *opaque)
             continue;
         }
 
-        throttle_account(&backend->ts, true, ret);
+        throttle_account(&backend->ts, THROTTLE_WRITE, ret);
         cryptodev_backend_operation(backend, op_info);
         if (throttle_enabled(&backend->tc) &&
-            throttle_schedule_timer(&backend->ts, &backend->tt, true)) {
+            throttle_schedule_timer(&backend->ts, &backend->tt,
+                                    THROTTLE_WRITE)) {
             break;
         }
     }
@@ -XXX,XX +XXX,XX @@ int cryptodev_backend_crypto_operation(
         goto do_account;
     }
 
-    if (throttle_schedule_timer(&backend->ts, &backend->tt, true) ||
+    if (throttle_schedule_timer(&backend->ts, &backend->tt, THROTTLE_WRITE) ||
         !QTAILQ_EMPTY(&backend->opinfos)) {
         QTAILQ_INSERT_TAIL(&backend->opinfos, op_info, next);
         return 0;
@@ -XXX,XX +XXX,XX @@ do_account:
         return ret;
     }
 
-    throttle_account(&backend->ts, true, ret);
+    throttle_account(&backend->ts, THROTTLE_WRITE, ret);
 
     return cryptodev_backend_operation(backend, op_info);
 }
diff --git a/block/throttle-groups.c b/block/throttle-groups.c
index XXXXXXX..XXXXXXX 100644
--- a/block/throttle-groups.c
+++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
     ThrottleState *ts = tgm->throttle_state;
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
     ThrottleTimers *tt = &tgm->throttle_timers;
+    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
     bool must_wait;
 
     if (qatomic_read(&tgm->io_limits_disabled)) {
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
         return true;
     }
 
-    must_wait = throttle_schedule_timer(ts, tt, is_write);
+    must_wait = throttle_schedule_timer(ts, tt, direction);
 
     /* If a timer just got armed, set tgm as the current token */
     if (must_wait) {
@@ -XXX,XX +XXX,XX @@ void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm
     bool must_wait;
     ThrottleGroupMember *token;
     ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
+    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
 
     assert(bytes >= 0);
 
@@ -XXX,XX +XXX,XX @@ void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm
     }
 
     /* The I/O will be executed, so do the accounting */
-    throttle_account(tgm->throttle_state, is_write, bytes);
+    throttle_account(tgm->throttle_state, direction, bytes);
 
     /* Schedule the next request */
     schedule_next_request(tgm, is_write);
diff --git a/fsdev/qemu-fsdev-throttle.c b/fsdev/qemu-fsdev-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/fsdev/qemu-fsdev-throttle.c
+++ b/fsdev/qemu-fsdev-throttle.c
@@ -XXX,XX +XXX,XX @@ void fsdev_throttle_init(FsThrottle *fst)
 void coroutine_fn fsdev_co_throttle_request(FsThrottle *fst, bool is_write,
                                             struct iovec *iov, int iovcnt)
 {
+    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
+
     if (throttle_enabled(&fst->cfg)) {
-        if (throttle_schedule_timer(&fst->ts, &fst->tt, is_write) ||
+        if (throttle_schedule_timer(&fst->ts, &fst->tt, direction) ||
             !qemu_co_queue_empty(&fst->throttled_reqs[is_write])) {
             qemu_co_queue_wait(&fst->throttled_reqs[is_write], NULL);
         }
 
-        throttle_account(&fst->ts, is_write, iov_size(iov, iovcnt));
+        throttle_account(&fst->ts, direction, iov_size(iov, iovcnt));
 
         if (!qemu_co_queue_empty(&fst->throttled_reqs[is_write]) &&
-            !throttle_schedule_timer(&fst->ts, &fst->tt, is_write)) {
+            !throttle_schedule_timer(&fst->ts, &fst->tt, direction)) {
             qemu_co_queue_next(&fst->throttled_reqs[is_write]);
         }
     }
diff --git a/tests/unit/test-throttle.c b/tests/unit/test-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-throttle.c
+++ b/tests/unit/test-throttle.c
@@ -XXX,XX +XXX,XX @@ static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
     throttle_config(&ts, QEMU_CLOCK_VIRTUAL, &cfg);
 
     /* account a read */
-    throttle_account(&ts, false, size);
+    throttle_account(&ts, THROTTLE_READ, size);
     /* account a write */
-    throttle_account(&ts, true, size);
+    throttle_account(&ts, THROTTLE_WRITE, size);
 
     /* check total result */
     index = to_test[is_ops][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 @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
 
 /* This function compute the time that must be waited while this IO
  *
- * @is_write:   true if the current IO is a write, false if it's a read
+ * @direction:  throttle direction
  * @ret:        time to wait
  */
 static int64_t throttle_compute_wait_for(ThrottleState *ts,
-                                         bool is_write)
+                                         ThrottleDirection direction)
 {
     BucketType to_check[2][4] = { {THROTTLE_BPS_TOTAL,
                                    THROTTLE_OPS_TOTAL,
@@ -XXX,XX +XXX,XX @@ static int64_t throttle_compute_wait_for(ThrottleState *ts,
     int i;
 
     for (i = 0; i < 4; i++) {
-        BucketType index = to_check[is_write][i];
+        BucketType index = to_check[direction][i];
         wait = throttle_compute_wait(&ts->cfg.buckets[index]);
         if (wait > max_wait) {
             max_wait = wait;
@@ -XXX,XX +XXX,XX @@ static int64_t throttle_compute_wait_for(ThrottleState *ts,
 
 /* compute the timer for this type of operation
  *
- * @is_write:   the type of operation
+ * @direction:  throttle direction
  * @now:        the current clock timestamp
  * @next_timestamp: the resulting timer
  * @ret:        true if a timer must be set
  */
 static bool throttle_compute_timer(ThrottleState *ts,
-                                   bool is_write,
+                                   ThrottleDirection direction,
                                    int64_t now,
                                    int64_t *next_timestamp)
 {
@@ -XXX,XX +XXX,XX @@ static bool throttle_compute_timer(ThrottleState *ts,
     throttle_do_leak(ts, now);
 
     /* compute the wait time if any */
-    wait = throttle_compute_wait_for(ts, is_write);
+    wait = throttle_compute_wait_for(ts, direction);
 
     /* if the code must wait compute when the next timer should fire */
     if (wait) {
@@ -XXX,XX +XXX,XX @@ void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
  * NOTE: this function is not unit tested due to it's usage of timer_mod
  *
  * @tt:       the timers structure
- * @is_write: the type of operation (read/write)
+ * @direction: throttle direction
  * @ret:      true if the timer has been scheduled else false
  */
 bool throttle_schedule_timer(ThrottleState *ts,
                              ThrottleTimers *tt,
-                             bool is_write)
+                             ThrottleDirection direction)
 {
     int64_t now = qemu_clock_get_ns(tt->clock_type);
     int64_t next_timestamp;
     QEMUTimer *timer;
     bool must_wait;
 
-    timer = is_write ? tt->timers[THROTTLE_WRITE] : tt->timers[THROTTLE_READ];
+    assert(direction < THROTTLE_MAX);
+    timer = tt->timers[direction];
     assert(timer);
 
     must_wait = throttle_compute_timer(ts,
-                                       is_write,
+                                       direction,
                                        now,
                                        &next_timestamp);
 
@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
 
 /* do the accounting for this operation
  *
- * @is_write: the type of operation (read/write)
+ * @direction: throttle direction
  * @size:     the size of the operation
  */
-void throttle_account(ThrottleState *ts, bool is_write, uint64_t size)
+void throttle_account(ThrottleState *ts, ThrottleDirection direction,
+                      uint64_t size)
 {
     const BucketType bucket_types_size[2][2] = {
         { THROTTLE_BPS_TOTAL, THROTTLE_BPS_READ },
@@ -XXX,XX +XXX,XX @@ void throttle_account(ThrottleState *ts, bool is_write, uint64_t size)
     double units = 1.0;
     unsigned i;
 
+    assert(direction < THROTTLE_MAX);
     /* if cfg.op_size is defined and smaller than size we compute unit count */
     if (ts->cfg.op_size && size > ts->cfg.op_size) {
         units = (double) size / ts->cfg.op_size;
@@ -XXX,XX +XXX,XX @@ void throttle_account(ThrottleState *ts, bool is_write, uint64_t size)
     for (i = 0; i < 2; i++) {
         LeakyBucket *bkt;
 
-        bkt = &ts->cfg.buckets[bucket_types_size[is_write][i]];
+        bkt = &ts->cfg.buckets[bucket_types_size[direction][i]];
         bkt->level += size;
         if (bkt->burst_length > 1) {
             bkt->burst_level += size;
         }
 
-        bkt = &ts->cfg.buckets[bucket_types_units[is_write][i]];
+        bkt = &ts->cfg.buckets[bucket_types_units[direction][i]];
         bkt->level += units;
         if (bkt->burst_length > 1) {
             bkt->burst_level += units;
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

The first dimension of both to_check and
bucket_types_size/bucket_types_units is used as throttle direction,
use THROTTLE_MAX instead of hard coded number. Also use ARRAY_SIZE()
to avoid hard coded number for the second dimension.

Hanna noticed that the two array should be static. Yes, turn them
into static variables.

Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-8-pizhenwei@bytedance.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 util/throttle.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 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 @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
 static int64_t throttle_compute_wait_for(ThrottleState *ts,
                                          ThrottleDirection direction)
 {
-    BucketType to_check[2][4] = { {THROTTLE_BPS_TOTAL,
+    static const BucketType to_check[THROTTLE_MAX][4] = {
+                                  {THROTTLE_BPS_TOTAL,
                                    THROTTLE_OPS_TOTAL,
                                    THROTTLE_BPS_READ,
                                    THROTTLE_OPS_READ},
@@ -XXX,XX +XXX,XX @@ static int64_t throttle_compute_wait_for(ThrottleState *ts,
     int64_t wait, max_wait = 0;
     int i;
 
-    for (i = 0; i < 4; i++) {
+    for (i = 0; i < ARRAY_SIZE(to_check[THROTTLE_READ]); i++) {
         BucketType index = to_check[direction][i];
         wait = throttle_compute_wait(&ts->cfg.buckets[index]);
         if (wait > max_wait) {
@@ -XXX,XX +XXX,XX @@ bool throttle_schedule_timer(ThrottleState *ts,
 void throttle_account(ThrottleState *ts, ThrottleDirection direction,
                       uint64_t size)
 {
-    const BucketType bucket_types_size[2][2] = {
+    static const BucketType bucket_types_size[THROTTLE_MAX][2] = {
         { THROTTLE_BPS_TOTAL, THROTTLE_BPS_READ },
         { THROTTLE_BPS_TOTAL, THROTTLE_BPS_WRITE }
     };
-    const BucketType bucket_types_units[2][2] = {
+    static const BucketType bucket_types_units[THROTTLE_MAX][2] = {
         { THROTTLE_OPS_TOTAL, THROTTLE_OPS_READ },
         { THROTTLE_OPS_TOTAL, THROTTLE_OPS_WRITE }
     };
@@ -XXX,XX +XXX,XX @@ void throttle_account(ThrottleState *ts, ThrottleDirection direction,
         units = (double) size / ts->cfg.op_size;
     }
 
-    for (i = 0; i < 2; i++) {
+    for (i = 0; i < ARRAY_SIZE(bucket_types_size[THROTTLE_READ]); i++) {
         LeakyBucket *bkt;
 
         bkt = &ts->cfg.buckets[bucket_types_size[direction][i]];
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

'bool is_write' style is obsolete from throttle framework, adapt
fsdev to the new style.

Cc: Greg Kurz <groug@kaod.org>
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-9-pizhenwei@bytedance.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 fsdev/qemu-fsdev-throttle.h |  4 ++--
 fsdev/qemu-fsdev-throttle.c | 14 +++++++-------
 hw/9pfs/cofile.c            |  4 ++--
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/fsdev/qemu-fsdev-throttle.h b/fsdev/qemu-fsdev-throttle.h
index XXXXXXX..XXXXXXX 100644
--- a/fsdev/qemu-fsdev-throttle.h
+++ b/fsdev/qemu-fsdev-throttle.h
@@ -XXX,XX +XXX,XX @@ typedef struct FsThrottle {
     ThrottleState ts;
     ThrottleTimers tt;
     ThrottleConfig cfg;
-    CoQueue      throttled_reqs[2];
+    CoQueue      throttled_reqs[THROTTLE_MAX];
 } FsThrottle;
 
 int fsdev_throttle_parse_opts(QemuOpts *, FsThrottle *, Error **);
 
 void fsdev_throttle_init(FsThrottle *);
 
-void coroutine_fn fsdev_co_throttle_request(FsThrottle *, bool ,
+void coroutine_fn fsdev_co_throttle_request(FsThrottle *, ThrottleDirection ,
                                             struct iovec *, int);
 
 void fsdev_throttle_cleanup(FsThrottle *);
diff --git a/fsdev/qemu-fsdev-throttle.c b/fsdev/qemu-fsdev-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/fsdev/qemu-fsdev-throttle.c
+++ b/fsdev/qemu-fsdev-throttle.c
@@ -XXX,XX +XXX,XX @@ void fsdev_throttle_init(FsThrottle *fst)
     }
 }
 
-void coroutine_fn fsdev_co_throttle_request(FsThrottle *fst, bool is_write,
+void coroutine_fn fsdev_co_throttle_request(FsThrottle *fst,
+                                            ThrottleDirection direction,
                                             struct iovec *iov, int iovcnt)
 {
-    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
-
+    assert(direction < THROTTLE_MAX);
     if (throttle_enabled(&fst->cfg)) {
         if (throttle_schedule_timer(&fst->ts, &fst->tt, direction) ||
-            !qemu_co_queue_empty(&fst->throttled_reqs[is_write])) {
-            qemu_co_queue_wait(&fst->throttled_reqs[is_write], NULL);
+            !qemu_co_queue_empty(&fst->throttled_reqs[direction])) {
+            qemu_co_queue_wait(&fst->throttled_reqs[direction], NULL);
         }
 
         throttle_account(&fst->ts, direction, iov_size(iov, iovcnt));
 
-        if (!qemu_co_queue_empty(&fst->throttled_reqs[is_write]) &&
+        if (!qemu_co_queue_empty(&fst->throttled_reqs[direction]) &&
             !throttle_schedule_timer(&fst->ts, &fst->tt, direction)) {
-            qemu_co_queue_next(&fst->throttled_reqs[is_write]);
+            qemu_co_queue_next(&fst->throttled_reqs[direction]);
         }
     }
 }
diff --git a/hw/9pfs/cofile.c b/hw/9pfs/cofile.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/9pfs/cofile.c
+++ b/hw/9pfs/cofile.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn v9fs_co_pwritev(V9fsPDU *pdu, V9fsFidState *fidp,
     if (v9fs_request_cancelled(pdu)) {
         return -EINTR;
     }
-    fsdev_co_throttle_request(s->ctx.fst, true, iov, iovcnt);
+    fsdev_co_throttle_request(s->ctx.fst, THROTTLE_WRITE, iov, iovcnt);
     v9fs_co_run_in_worker(
         {
             err = s->ops->pwritev(&s->ctx, &fidp->fs, iov, iovcnt, offset);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn v9fs_co_preadv(V9fsPDU *pdu, V9fsFidState *fidp,
     if (v9fs_request_cancelled(pdu)) {
         return -EINTR;
     }
-    fsdev_co_throttle_request(s->ctx.fst, false, iov, iovcnt);
+    fsdev_co_throttle_request(s->ctx.fst, THROTTLE_READ, iov, iovcnt);
     v9fs_co_run_in_worker(
         {
             err = s->ops->preadv(&s->ctx, &fidp->fs, iov, iovcnt, offset);
-- 
2.41.0

From: zhenwei pi <pizhenwei@bytedance.com>

'bool is_write' style is obsolete from throttle framework, adapt
block throttle groups to the new style:
- use ThrottleDirection instead of 'bool is_write'. Ex,
  schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
  -> schedule_next_request(ThrottleGroupMember *tgm, ThrottleDirection direction)

- use THROTTLE_MAX instead of hard code. Ex, ThrottleGroupMember *tokens[2]
  -> ThrottleGroupMember *tokens[THROTTLE_MAX]

- use ThrottleDirection instead of hard code on iteration. Ex, (i = 0; i < 2; i++)
  -> for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++)

Use a simple python script to test the new style:
 #!/usr/bin/python3
import subprocess
import random
import time

commands = ['virsh blkdeviotune jammy vda --write-bytes-sec ', \
            'virsh blkdeviotune jammy vda --write-iops-sec ', \
            'virsh blkdeviotune jammy vda --read-bytes-sec ', \
            'virsh blkdeviotune jammy vda --read-iops-sec ']

for loop in range(1, 1000):
    time.sleep(random.randrange(3, 5))
    command = commands[random.randrange(0, 3)] + str(random.randrange(0, 1000000))
    subprocess.run(command, shell=True, check=True)

This works fine.

Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Message-Id: <20230728022006.1098509-10-pizhenwei@bytedance.com>
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 include/block/throttle-groups.h |   6 +-
 block/block-backend.c           |   4 +-
 block/throttle-groups.c         | 161 ++++++++++++++++----------------
 block/throttle.c                |   8 +-
 4 files changed, 90 insertions(+), 89 deletions(-)

diff --git a/include/block/throttle-groups.h b/include/block/throttle-groups.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/throttle-groups.h
+++ b/include/block/throttle-groups.h
@@ -XXX,XX +XXX,XX @@ typedef struct ThrottleGroupMember {
     AioContext   *aio_context;
     /* throttled_reqs_lock protects the CoQueues for throttled requests.  */
     CoMutex      throttled_reqs_lock;
-    CoQueue      throttled_reqs[2];
+    CoQueue      throttled_reqs[THROTTLE_MAX];
 
     /* Nonzero if the I/O limits are currently being ignored; generally
      * it is zero.  Accessed with atomic operations.
@@ -XXX,XX +XXX,XX @@ typedef struct ThrottleGroupMember {
      * throttle_state tells us if I/O limits are configured. */
     ThrottleState *throttle_state;
     ThrottleTimers throttle_timers;
-    unsigned       pending_reqs[2];
+    unsigned       pending_reqs[THROTTLE_MAX];
     QLIST_ENTRY(ThrottleGroupMember) round_robin;
 
 } ThrottleGroupMember;
@@ -XXX,XX +XXX,XX @@ void throttle_group_restart_tgm(ThrottleGroupMember *tgm);
 
 void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm,
                                                         int64_t bytes,
-                                                        bool is_write);
+                                                        ThrottleDirection direction);
 void throttle_group_attach_aio_context(ThrottleGroupMember *tgm,
                                        AioContext *new_context);
 void throttle_group_detach_aio_context(ThrottleGroupMember *tgm);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
     /* throttling disk I/O */
     if (blk->public.throttle_group_member.throttle_state) {
         throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
-                bytes, false);
+                bytes, THROTTLE_READ);
     }
 
     ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
@@ -XXX,XX +XXX,XX @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
     /* throttling disk I/O */
     if (blk->public.throttle_group_member.throttle_state) {
         throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
-                bytes, true);
+                bytes, THROTTLE_WRITE);
     }
 
     if (!blk->enable_write_cache) {
diff --git a/block/throttle-groups.c b/block/throttle-groups.c
index XXXXXXX..XXXXXXX 100644
--- a/block/throttle-groups.c
+++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@
 
 static void throttle_group_obj_init(Object *obj);
 static void throttle_group_obj_complete(UserCreatable *obj, Error **errp);
-static void timer_cb(ThrottleGroupMember *tgm, bool is_write);
+static void timer_cb(ThrottleGroupMember *tgm, ThrottleDirection direction);
 
 /* The ThrottleGroup structure (with its ThrottleState) is shared
  * among different ThrottleGroupMembers and it's independent from
@@ -XXX,XX +XXX,XX @@ struct ThrottleGroup {
     QemuMutex lock; /* This lock protects the following four fields */
     ThrottleState ts;
     QLIST_HEAD(, ThrottleGroupMember) head;
-    ThrottleGroupMember *tokens[2];
-    bool any_timer_armed[2];
+    ThrottleGroupMember *tokens[THROTTLE_MAX];
+    bool any_timer_armed[THROTTLE_MAX];
     QEMUClockType clock_type;
 
     /* This field is protected by the global QEMU mutex */
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *throttle_group_next_tgm(ThrottleGroupMember *tgm)
  * This assumes that tg->lock is held.
  *
  * @tgm:        the ThrottleGroupMember
- * @is_write:   the type of operation (read/write)
+ * @direction:  the ThrottleDirection
  * @ret:        whether the ThrottleGroupMember has pending requests.
  */
 static inline bool tgm_has_pending_reqs(ThrottleGroupMember *tgm,
-                                        bool is_write)
+                                        ThrottleDirection direction)
 {
-    return tgm->pending_reqs[is_write];
+    return tgm->pending_reqs[direction];
 }
 
 /* Return the next ThrottleGroupMember in the round-robin sequence with pending
@@ -XXX,XX +XXX,XX @@ static inline bool tgm_has_pending_reqs(ThrottleGroupMember *tgm,
  * This assumes that tg->lock is held.
  *
  * @tgm:       the current ThrottleGroupMember
- * @is_write:  the type of operation (read/write)
+ * @direction: the ThrottleDirection
  * @ret:       the next ThrottleGroupMember with pending requests, or tgm if
  *             there is none.
  */
 static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
-                                                bool is_write)
+                                                ThrottleDirection direction)
 {
     ThrottleState *ts = tgm->throttle_state;
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
      * it's being drained. Skip the round-robin search and return tgm
      * immediately if it has pending requests. Otherwise we could be
      * forcing it to wait for other member's throttled requests. */
-    if (tgm_has_pending_reqs(tgm, is_write) &&
+    if (tgm_has_pending_reqs(tgm, direction) &&
         qatomic_read(&tgm->io_limits_disabled)) {
         return tgm;
     }
 
-    start = token = tg->tokens[is_write];
+    start = token = tg->tokens[direction];
 
     /* get next bs round in round robin style */
     token = throttle_group_next_tgm(token);
-    while (token != start && !tgm_has_pending_reqs(token, is_write)) {
+    while (token != start && !tgm_has_pending_reqs(token, direction)) {
         token = throttle_group_next_tgm(token);
     }
 
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
      * then decide the token is the current tgm because chances are
      * the current tgm got the current request queued.
      */
-    if (token == start && !tgm_has_pending_reqs(token, is_write)) {
+    if (token == start && !tgm_has_pending_reqs(token, direction)) {
         token = tgm;
     }
 
     /* Either we return the original TGM, or one with pending requests */
-    assert(token == tgm || tgm_has_pending_reqs(token, is_write));
+    assert(token == tgm || tgm_has_pending_reqs(token, direction));
 
     return token;
 }
@@ -XXX,XX +XXX,XX @@ static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
  * This assumes that tg->lock is held.
  *
  * @tgm:        the current ThrottleGroupMember
- * @is_write:   the type of operation (read/write)
+ * @direction:  the ThrottleDirection
  * @ret:        whether the I/O request needs to be throttled or not
  */
 static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
-                                          bool is_write)
+                                          ThrottleDirection direction)
 {
     ThrottleState *ts = tgm->throttle_state;
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
     ThrottleTimers *tt = &tgm->throttle_timers;
-    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
     bool must_wait;
 
     if (qatomic_read(&tgm->io_limits_disabled)) {
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
     }
 
     /* Check if any of the timers in this group is already armed */
-    if (tg->any_timer_armed[is_write]) {
+    if (tg->any_timer_armed[direction]) {
         return true;
     }
 
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
 
     /* If a timer just got armed, set tgm as the current token */
     if (must_wait) {
-        tg->tokens[is_write] = tgm;
-        tg->any_timer_armed[is_write] = true;
+        tg->tokens[direction] = tgm;
+        tg->any_timer_armed[direction] = true;
     }
 
     return must_wait;
@@ -XXX,XX +XXX,XX @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
  * any request was actually pending.
  *
  * @tgm:       the current ThrottleGroupMember
- * @is_write:  the type of operation (read/write)
+ * @direction: the ThrottleDirection
  */
 static bool coroutine_fn throttle_group_co_restart_queue(ThrottleGroupMember *tgm,
-                                                         bool is_write)
+                                                         ThrottleDirection direction)
 {
     bool ret;
 
     qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
-    ret = qemu_co_queue_next(&tgm->throttled_reqs[is_write]);
+    ret = qemu_co_queue_next(&tgm->throttled_reqs[direction]);
     qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
 
     return ret;
@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn throttle_group_co_restart_queue(ThrottleGroupMember *tg
  * This assumes that tg->lock is held.
  *
  * @tgm:       the current ThrottleGroupMember
- * @is_write:  the type of operation (read/write)
+ * @direction: the ThrottleDirection
  */
-static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
+static void schedule_next_request(ThrottleGroupMember *tgm,
+                                  ThrottleDirection direction)
 {
     ThrottleState *ts = tgm->throttle_state;
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
@@ -XXX,XX +XXX,XX @@ static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
     ThrottleGroupMember *token;
 
     /* Check if there's any pending request to schedule next */
-    token = next_throttle_token(tgm, is_write);
-    if (!tgm_has_pending_reqs(token, is_write)) {
+    token = next_throttle_token(tgm, direction);
+    if (!tgm_has_pending_reqs(token, direction)) {
         return;
     }
 
     /* Set a timer for the request if it needs to be throttled */
-    must_wait = throttle_group_schedule_timer(token, is_write);
+    must_wait = throttle_group_schedule_timer(token, direction);
 
     /* If it doesn't have to wait, queue it for immediate execution */
     if (!must_wait) {
         /* Give preference to requests from the current tgm */
         if (qemu_in_coroutine() &&
-            throttle_group_co_restart_queue(tgm, is_write)) {
+            throttle_group_co_restart_queue(tgm, direction)) {
             token = tgm;
         } else {
             ThrottleTimers *tt = &token->throttle_timers;
             int64_t now = qemu_clock_get_ns(tg->clock_type);
-            timer_mod(tt->timers[is_write], now);
-            tg->any_timer_armed[is_write] = true;
+            timer_mod(tt->timers[direction], now);
+            tg->any_timer_armed[direction] = true;
         }
-        tg->tokens[is_write] = token;
+        tg->tokens[direction] = token;
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
  *
  * @tgm:       the current ThrottleGroupMember
  * @bytes:     the number of bytes for this I/O
- * @is_write:  the type of operation (read/write)
+ * @direction: the ThrottleDirection
  */
 void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm,
                                                         int64_t bytes,
-                                                        bool is_write)
+                                                        ThrottleDirection direction)
 {
     bool must_wait;
     ThrottleGroupMember *token;
     ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
-    ThrottleDirection direction = is_write ? THROTTLE_WRITE : THROTTLE_READ;
 
     assert(bytes >= 0);
+    assert(direction < THROTTLE_MAX);
 
     qemu_mutex_lock(&tg->lock);
 
     /* First we check if this I/O has to be throttled. */
-    token = next_throttle_token(tgm, is_write);
-    must_wait = throttle_group_schedule_timer(token, is_write);
+    token = next_throttle_token(tgm, direction);
+    must_wait = throttle_group_schedule_timer(token, direction);
 
     /* Wait if there's a timer set or queued requests of this type */
-    if (must_wait || tgm->pending_reqs[is_write]) {
-        tgm->pending_reqs[is_write]++;
+    if (must_wait || tgm->pending_reqs[direction]) {
+        tgm->pending_reqs[direction]++;
         qemu_mutex_unlock(&tg->lock);
         qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
-        qemu_co_queue_wait(&tgm->throttled_reqs[is_write],
+        qemu_co_queue_wait(&tgm->throttled_reqs[direction],
                            &tgm->throttled_reqs_lock);
         qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
         qemu_mutex_lock(&tg->lock);
-        tgm->pending_reqs[is_write]--;
+        tgm->pending_reqs[direction]--;
     }
 
     /* The I/O will be executed, so do the accounting */
     throttle_account(tgm->throttle_state, direction, bytes);
 
     /* Schedule the next request */
-    schedule_next_request(tgm, is_write);
+    schedule_next_request(tgm, direction);
 
     qemu_mutex_unlock(&tg->lock);
 }
 
 typedef struct {
     ThrottleGroupMember *tgm;
-    bool is_write;
+    ThrottleDirection direction;
 } RestartData;
 
 static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
     ThrottleGroupMember *tgm = data->tgm;
     ThrottleState *ts = tgm->throttle_state;
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
-    bool is_write = data->is_write;
+    ThrottleDirection direction = data->direction;
     bool empty_queue;
 
-    empty_queue = !throttle_group_co_restart_queue(tgm, is_write);
+    empty_queue = !throttle_group_co_restart_queue(tgm, direction);
 
     /* If the request queue was empty then we have to take care of
      * scheduling the next one */
     if (empty_queue) {
         qemu_mutex_lock(&tg->lock);
-        schedule_next_request(tgm, is_write);
+        schedule_next_request(tgm, direction);
         qemu_mutex_unlock(&tg->lock);
     }
 
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
     aio_wait_kick();
 }
 
-static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write)
+static void throttle_group_restart_queue(ThrottleGroupMember *tgm,
+                                        ThrottleDirection direction)
 {
     Coroutine *co;
     RestartData *rd = g_new0(RestartData, 1);
 
     rd->tgm = tgm;
-    rd->is_write = is_write;
+    rd->direction = direction;
 
     /* This function is called when a timer is fired or when
      * throttle_group_restart_tgm() is called. Either way, there can
      * be no timer pending on this tgm at this point */
-    assert(!timer_pending(tgm->throttle_timers.timers[is_write]));
+    assert(!timer_pending(tgm->throttle_timers.timers[direction]));
 
     qatomic_inc(&tgm->restart_pending);
 
@@ -XXX,XX +XXX,XX @@ static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write
 
 void throttle_group_restart_tgm(ThrottleGroupMember *tgm)
 {
-    int i;
+    ThrottleDirection dir;
 
     if (tgm->throttle_state) {
-        for (i = 0; i < 2; i++) {
-            QEMUTimer *t = tgm->throttle_timers.timers[i];
+        for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+            QEMUTimer *t = tgm->throttle_timers.timers[dir];
             if (timer_pending(t)) {
                 /* If there's a pending timer on this tgm, fire it now */
                 timer_del(t);
-                timer_cb(tgm, i);
+                timer_cb(tgm, dir);
             } else {
                 /* Else run the next request from the queue manually */
-                throttle_group_restart_queue(tgm, i);
+                throttle_group_restart_queue(tgm, dir);
             }
         }
     }
@@ -XXX,XX +XXX,XX @@ void throttle_group_get_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg)
  * because it had been throttled.
  *
  * @tgm:       the ThrottleGroupMember whose request had been throttled
- * @is_write:  the type of operation (read/write)
+ * @direction: the ThrottleDirection
  */
-static void timer_cb(ThrottleGroupMember *tgm, bool is_write)
+static void timer_cb(ThrottleGroupMember *tgm, ThrottleDirection direction)
 {
     ThrottleState *ts = tgm->throttle_state;
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 
     /* The timer has just been fired, so we can update the flag */
     qemu_mutex_lock(&tg->lock);
-    tg->any_timer_armed[is_write] = false;
+    tg->any_timer_armed[direction] = false;
     qemu_mutex_unlock(&tg->lock);
 
     /* Run the request that was waiting for this timer */
-    throttle_group_restart_queue(tgm, is_write);
+    throttle_group_restart_queue(tgm, direction);
 }
 
 static void read_timer_cb(void *opaque)
 {
-    timer_cb(opaque, false);
+    timer_cb(opaque, THROTTLE_READ);
 }
 
 static void write_timer_cb(void *opaque)
 {
-    timer_cb(opaque, true);
+    timer_cb(opaque, THROTTLE_WRITE);
 }
 
 /* Register a ThrottleGroupMember from the throttling group, also initializing
@@ -XXX,XX +XXX,XX @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm,
                                  const char *groupname,
                                  AioContext *ctx)
 {
-    int i;
+    ThrottleDirection dir;
     ThrottleState *ts = throttle_group_incref(groupname);
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 
@@ -XXX,XX +XXX,XX @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm,
 
     QEMU_LOCK_GUARD(&tg->lock);
     /* If the ThrottleGroup is new set this ThrottleGroupMember as the token */
-    for (i = 0; i < 2; i++) {
-        if (!tg->tokens[i]) {
-            tg->tokens[i] = tgm;
+    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+        if (!tg->tokens[dir]) {
+            tg->tokens[dir] = tgm;
         }
+        qemu_co_queue_init(&tgm->throttled_reqs[dir]);
     }
 
     QLIST_INSERT_HEAD(&tg->head, tgm, round_robin);
@@ -XXX,XX +XXX,XX @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm,
                          write_timer_cb,
                          tgm);
     qemu_co_mutex_init(&tgm->throttled_reqs_lock);
-    qemu_co_queue_init(&tgm->throttled_reqs[0]);
-    qemu_co_queue_init(&tgm->throttled_reqs[1]);
 }
 
 /* Unregister a ThrottleGroupMember from its group, removing it from the list,
@@ -XXX,XX +XXX,XX @@ void throttle_group_unregister_tgm(ThrottleGroupMember *tgm)
     ThrottleState *ts = tgm->throttle_state;
     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
     ThrottleGroupMember *token;
-    int i;
+    ThrottleDirection dir;
 
     if (!ts) {
         /* Discard already unregistered tgm */
@@ -XXX,XX +XXX,XX @@ void throttle_group_unregister_tgm(ThrottleGroupMember *tgm)
     AIO_WAIT_WHILE(tgm->aio_context, qatomic_read(&tgm->restart_pending) > 0);
 
     WITH_QEMU_LOCK_GUARD(&tg->lock) {
-        for (i = 0; i < 2; i++) {
-            assert(tgm->pending_reqs[i] == 0);
-            assert(qemu_co_queue_empty(&tgm->throttled_reqs[i]));
-            assert(!timer_pending(tgm->throttle_timers.timers[i]));
-            if (tg->tokens[i] == tgm) {
+        for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+            assert(tgm->pending_reqs[dir] == 0);
+            assert(qemu_co_queue_empty(&tgm->throttled_reqs[dir]));
+            assert(!timer_pending(tgm->throttle_timers.timers[dir]));
+            if (tg->tokens[dir] == tgm) {
                 token = throttle_group_next_tgm(tgm);
                 /* Take care of the case where this is the last tgm in the group */
                 if (token == tgm) {
                     token = NULL;
                 }
-                tg->tokens[i] = token;
+                tg->tokens[dir] = token;
             }
         }
 
@@ -XXX,XX +XXX,XX @@ void throttle_group_detach_aio_context(ThrottleGroupMember *tgm)
 {
     ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
     ThrottleTimers *tt = &tgm->throttle_timers;
-    int i;
+    ThrottleDirection dir;
 
     /* Requests must have been drained */
-    assert(tgm->pending_reqs[0] == 0 && tgm->pending_reqs[1] == 0);
-    assert(qemu_co_queue_empty(&tgm->throttled_reqs[0]));
-    assert(qemu_co_queue_empty(&tgm->throttled_reqs[1]));
+    for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+        assert(tgm->pending_reqs[dir] == 0);
+        assert(qemu_co_queue_empty(&tgm->throttled_reqs[dir]));
+    }
 
     /* Kick off next ThrottleGroupMember, if necessary */
     WITH_QEMU_LOCK_GUARD(&tg->lock) {
-        for (i = 0; i < 2; i++) {
-            if (timer_pending(tt->timers[i])) {
-                tg->any_timer_armed[i] = false;
-                schedule_next_request(tgm, i);
+        for (dir = THROTTLE_READ; dir < THROTTLE_MAX; dir++) {
+            if (timer_pending(tt->timers[dir])) {
+                tg->any_timer_armed[dir] = false;
+                schedule_next_request(tgm, dir);
             }
         }
     }
diff --git a/block/throttle.c b/block/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/block/throttle.c
+++ b/block/throttle.c
@@ -XXX,XX +XXX,XX @@ throttle_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
 {
 
     ThrottleGroupMember *tgm = bs->opaque;
-    throttle_group_co_io_limits_intercept(tgm, bytes, false);
+    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_READ);
 
     return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 }
@@ -XXX,XX +XXX,XX @@ throttle_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
                     QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
     ThrottleGroupMember *tgm = bs->opaque;
-    throttle_group_co_io_limits_intercept(tgm, bytes, true);
+    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_WRITE);
 
     return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
 }
@@ -XXX,XX +XXX,XX @@ throttle_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
                           BdrvRequestFlags flags)
 {
     ThrottleGroupMember *tgm = bs->opaque;
-    throttle_group_co_io_limits_intercept(tgm, bytes, true);
+    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_WRITE);
 
     return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn GRAPH_RDLOCK
 throttle_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
 {
     ThrottleGroupMember *tgm = bs->opaque;
-    throttle_group_co_io_limits_intercept(tgm, bytes, true);
+    throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_WRITE);
 
     return bdrv_co_pdiscard(bs->file, offset, bytes);
 }
-- 
2.41.0

bs->bl.zoned is what indicates whether the zone information is present
and valid; it is the only thing that raw_refresh_zoned_limits() sets if
CONFIG_BLKZONED is not defined, and it is also the only thing that it
sets if CONFIG_BLKZONED is defined, but there are no zones.

Make sure that it is always set to BLK_Z_NONE if there is an error
anywhere in raw_refresh_zoned_limits() so that we do not accidentally
announce zones while our information is incomplete or invalid.

This also fixes a memory leak in the last error path in
raw_refresh_zoned_limits().

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
Message-Id: <20230824155345.109765-2-hreitz@redhat.com>
Reviewed-by: Sam Li <faithilikerun@gmail.com>
---
 block/file-posix.c | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
     BlockZoneModel zoned;
     int ret;
 
-    bs->bl.zoned = BLK_Z_NONE;
-
     ret = get_sysfs_zoned_model(st, &zoned);
     if (ret < 0 || zoned == BLK_Z_NONE) {
-        return;
+        goto no_zoned;
     }
     bs->bl.zoned = zoned;
 
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Unable to read chunk_sectors "
                                      "sysfs attribute");
-        return;
+        goto no_zoned;
     } else if (!ret) {
         error_setg(errp, "Read 0 from chunk_sectors sysfs attribute");
-        return;
+        goto no_zoned;
     }
     bs->bl.zone_size = ret << BDRV_SECTOR_BITS;
 
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Unable to read nr_zones "
                                      "sysfs attribute");
-        return;
+        goto no_zoned;
     } else if (!ret) {
         error_setg(errp, "Read 0 from nr_zones sysfs attribute");
-        return;
+        goto no_zoned;
     }
     bs->bl.nr_zones = ret;
 
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
     ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "report wps failed");
-        bs->wps = NULL;
-        return;
+        goto no_zoned;
     }
     qemu_co_mutex_init(&bs->wps->colock);
+    return;
+
+no_zoned:
+    bs->bl.zoned = BLK_Z_NONE;
+    g_free(bs->wps);
+    bs->wps = NULL;
 }
 #else /* !defined(CONFIG_BLKZONED) */
 static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
-- 
2.41.0

Instead of checking bs->wps or bs->bl.zone_size for whether zone
information is present, check bs->bl.zoned.  That is the flag that
raw_refresh_zoned_limits() reliably sets to indicate zone support.  If
it is set to something other than BLK_Z_NONE, other values and objects
like bs->wps and bs->bl.zone_size must be non-null/zero and valid; if it
is not, we cannot rely on their validity.

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
Message-Id: <20230824155345.109765-3-hreitz@redhat.com>
Reviewed-by: Sam Li <faithilikerun@gmail.com>
---
 block/file-posix.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
     if (fd_open(bs) < 0)
         return -EIO;
 #if defined(CONFIG_BLKZONED)
-    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && bs->wps) {
+    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
+        bs->bl.zoned != BLK_Z_NONE) {
         qemu_co_mutex_lock(&bs->wps->colock);
-        if (type & QEMU_AIO_ZONE_APPEND && bs->bl.zone_size) {
+        if (type & QEMU_AIO_ZONE_APPEND) {
             int index = offset / bs->bl.zone_size;
             offset = bs->wps->wp[index];
         }
@@ -XXX,XX +XXX,XX @@ out:
 {
     BlockZoneWps *wps = bs->wps;
     if (ret == 0) {
-        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))
-            && wps && bs->bl.zone_size) {
+        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
+            bs->bl.zoned != BLK_Z_NONE) {
             uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
             if (!BDRV_ZT_IS_CONV(*wp)) {
                 if (type & QEMU_AIO_ZONE_APPEND) {
@@ -XXX,XX +XXX,XX @@ out:
         }
     }
 
-    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && wps) {
+    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
+        bs->blk.zoned != BLK_Z_NONE) {
         qemu_co_mutex_unlock(&wps->colock);
     }
 }
-- 
2.41.0

We duplicate the same condition three times here, pull it out to the top
level.

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
Message-Id: <20230824155345.109765-5-hreitz@redhat.com>
Reviewed-by: Sam Li <faithilikerun@gmail.com>
---
 block/file-posix.c | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
 
 out:
 #if defined(CONFIG_BLKZONED)
-{
-    BlockZoneWps *wps = bs->wps;
-    if (ret == 0) {
-        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-            bs->bl.zoned != BLK_Z_NONE) {
+    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
+        bs->bl.zoned != BLK_Z_NONE) {
+        BlockZoneWps *wps = bs->wps;
+        if (ret == 0) {
             uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
             if (!BDRV_ZT_IS_CONV(*wp)) {
                 if (type & QEMU_AIO_ZONE_APPEND) {
@@ -XXX,XX +XXX,XX @@ out:
                     *wp = offset + bytes;
                 }
             }
-        }
-    } else {
-        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-            bs->bl.zoned != BLK_Z_NONE) {
+        } else {
             update_zones_wp(bs, s->fd, 0, 1);
         }
-    }
 
-    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
-        bs->blk.zoned != BLK_Z_NONE) {
         qemu_co_mutex_unlock(&wps->colock);
     }
-}
 #endif
     return ret;
 }
-- 
2.41.0

This is a regression test for
https://bugzilla.redhat.com/show_bug.cgi?id=2234374.

All this test needs to do is trigger an I/O error inside of file-posix
(specifically raw_co_prw()).  One reliable way to do this without
requiring special privileges is to use a FUSE export, which allows us to
inject any error that we want, e.g. via blkdebug.

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
Message-Id: <20230824155345.109765-6-hreitz@redhat.com>
[hreitz: Fixed test to be skipped when there is no FUSE support, to
         suppress fusermount's allow_other warning, and to be skipped
         with $IMGOPTSSYNTAX enabled]
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>
---
 tests/qemu-iotests/tests/file-io-error     | 119 +++++++++++++++++++++
 tests/qemu-iotests/tests/file-io-error.out |  33 ++++++
 2 files changed, 152 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/file-io-error
 create mode 100644 tests/qemu-iotests/tests/file-io-error.out

diff --git a/tests/qemu-iotests/tests/file-io-error b/tests/qemu-iotests/tests/file-io-error
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/file-io-error
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+# group: rw
+#
+# Produce an I/O error in file-posix, and hope that it is not catastrophic.
+# Regression test for: https://bugzilla.redhat.com/show_bug.cgi?id=2234374
+#
+# Copyright (C) 2023 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+seq=$(basename "$0")
+echo "QA output created by $seq"
+
+status=1	# failure is the default!
+
+_cleanup()
+{
+    _cleanup_qemu
+    rm -f "$TEST_DIR/fuse-export"
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ../common.rc
+. ../common.filter
+. ../common.qemu
+
+# Format-agnostic (we do not use any), but we do test the file protocol
+_supported_proto file
+_require_drivers blkdebug null-co
+
+if [ "$IMGOPTSSYNTAX" = "true" ]; then
+    # We need `$QEMU_IO -f file` to work; IMGOPTSSYNTAX uses --image-opts,
+    # breaking -f.
+    _unsupported_fmt $IMGFMT
+fi
+
+# This is a regression test of a bug in which flie-posix would access zone
+# information in case of an I/O error even when there is no zone information,
+# resulting in a division by zero.
+# To reproduce the problem, we need to trigger an I/O error inside of
+# file-posix, which can be done (rootless) by providing a FUSE export that
+# presents only errors when accessed.
+
+_launch_qemu
+_send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'qmp_capabilities'}" \
+    'return'
+
+_send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'blockdev-add',
+      'arguments': {
+          'driver': 'blkdebug',
+          'node-name': 'node0',
+          'inject-error': [{'event': 'none'}],
+          'image': {
+              'driver': 'null-co'
+          }
+      }}" \
+    'return'
+
+# FUSE mountpoint must exist and be a regular file
+touch "$TEST_DIR/fuse-export"
+
+# The grep -v to filter fusermount's (benign) error when /etc/fuse.conf does
+# not contain user_allow_other and the subsequent check for missing FUSE support
+# have both been taken from iotest 308.
+output=$(_send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'block-export-add',
+      'arguments': {
+          'id': 'exp0',
+          'type': 'fuse',
+          'node-name': 'node0',
+          'mountpoint': '$TEST_DIR/fuse-export',
+          'writable': true
+      }}" \
+    'return' \
+    | grep -v 'option allow_other only allowed if')
+
+if echo "$output" | grep -q "Parameter 'type' does not accept value 'fuse'"; then
+    _notrun 'No FUSE support'
+fi
+echo "$output"
+
+echo
+# This should fail, but gracefully, i.e. just print an I/O error, not crash.
+$QEMU_IO -f file -c 'write 0 64M' "$TEST_DIR/fuse-export" | _filter_qemu_io
+echo
+
+_send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'block-export-del',
+      'arguments': {'id': 'exp0'}}" \
+    'return'
+
+_send_qemu_cmd $QEMU_HANDLE \
+    '' \
+    'BLOCK_EXPORT_DELETED'
+
+_send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'blockdev-del',
+      'arguments': {'node-name': 'node0'}}" \
+    'return'
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/tests/file-io-error.out b/tests/qemu-iotests/tests/file-io-error.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/file-io-error.out
@@ -XXX,XX +XXX,XX @@
+QA output created by file-io-error
+{'execute': 'qmp_capabilities'}
+{"return": {}}
+{'execute': 'blockdev-add',
+      'arguments': {
+          'driver': 'blkdebug',
+          'node-name': 'node0',
+          'inject-error': [{'event': 'none'}],
+          'image': {
+              'driver': 'null-co'
+          }
+      }}
+{"return": {}}
+{'execute': 'block-export-add',
+      'arguments': {
+          'id': 'exp0',
+          'type': 'fuse',
+          'node-name': 'node0',
+          'mountpoint': 'TEST_DIR/fuse-export',
+          'writable': true
+      }}
+{"return": {}}
+
+write failed: Input/output error
+
+{'execute': 'block-export-del',
+      'arguments': {'id': 'exp0'}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_EXPORT_DELETED", "data": {"id": "exp0"}}
+{'execute': 'blockdev-del',
+      'arguments': {'node-name': 'node0'}}
+{"return": {}}
+*** done
-- 
2.41.0