Series comparison

-[PULL for-6.1 0/3] Block patches
+[PULL for-7.0 0/2] Block patches
-The following changes since commit 801f3db7564dcce8a37a70833c0abe40ec19f8ce:
+The following changes since commit 15ef89d2a1a7b93845a6b09c2ee8e1979f6eb30b:
-  Merge remote-tracking branch 'remotes/philmd/tags/kconfig-20210720' into staging (2021-07-20 19:30:28 +0100)
+  Update version for v7.0.0-rc1 release (2022-03-22 22:58:44 +0000)
 are available in the Git repository at:
   https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to d7ddd0a1618a75b31dc308bb37365ce1da972154:
+for you to fetch changes up to 2539eade4f689eda7e9fe45486f18334bfbafaf0:
-  linux-aio: limit the batch size using `aio-max-batch` parameter (2021-07-21 13:47:50 +0100)
+  hw: Fix misleading hexadecimal format (2022-03-24 10:38:42 +0000)
 ----------------------------------------------------------------
 Pull request
-Stefano's performance regression fix for commit 2558cb8dd4 ("linux-aio:
+Philippe found cases where the 0x%d format string was used, leading to
-increasing MAX_EVENTS to a larger hardcoded value").
+misleading output. The patches look harmless and could save people time, so I
 think it's worth including them in 7.0.
 ----------------------------------------------------------------
-Stefano Garzarella (3):
+Philippe Mathieu-Daudé (2):
-  iothread: generalize iothread_set_param/iothread_get_param
+  block: Fix misleading hexadecimal format
-  iothread: add aio-max-batch parameter
+  hw: Fix misleading hexadecimal format
   linux-aio: limit the batch size using `aio-max-batch` parameter
- qapi/misc.json            |  6 ++-
+ block/parallels-ext.c | 2 +-
- qapi/qom.json             |  7 +++-
+ hw/i386/sgx.c         | 2 +-
- include/block/aio.h       | 12 ++++++
+ hw/i386/trace-events  | 6 +++---
- include/sysemu/iothread.h |  3 ++
+ hw/misc/trace-events  | 4 ++--
- block/linux-aio.c         |  9 ++++-
+ hw/scsi/trace-events  | 4 ++--
- iothread.c                | 82 ++++++++++++++++++++++++++++++++++-----
+files changed, 9 insertions(+), 9 deletions(-)
  monitor/hmp-cmds.c        |  2 +
  util/aio-posix.c          | 12 ++++++
  util/aio-win32.c          |  5 +++
  util/async.c              |  2 +
  qemu-options.hx           |  8 +++-
 files changed, 134 insertions(+), 14 deletions(-)
 --
-.31.1
+.35.1

-[PULL for-6.1 3/3] linux-aio: limit the batch size using `aio-max-batch` parameter
+[PULL for-7.0 1/2] block: Fix misleading hexadecimal format
-From: Stefano Garzarella <sgarzare@redhat.com>
+From: Philippe Mathieu-Daudé <f4bug@amsat.org>
-When there are multiple queues attached to the same AIO context,
+"0x%u" format is very misleading, replace by "0x%x".
 some requests may experience high latency, since in the worst case
 the AIO engine queue is only flushed when it is full (MAX_EVENTS) or
 there are no more queues plugged.
-Commit 2558cb8dd4 ("linux-aio: increasing MAX_EVENTS to a larger
+Found running:
 hardcoded value") changed MAX_EVENTS from 128 to 1024, to increase
 the number of in-flight requests. But this change also increased
 the potential maximum batch to 1024 elements.
-When there is a single queue attached to the AIO context, the issue
+  $ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' block/
 is mitigated from laio_io_unplug() that will flush the queue every
 time is invoked since there can't be others queue plugged.
-Let's use the new `aio-max-batch` IOThread parameter to mitigate
+Inspired-by: Richard Henderson <richard.henderson@linaro.org>
-this issue, limiting the number of requests in a batch.
+Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-We also define a default value (32): this value is obtained running
+Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
-some benchmarks and it represents a good tradeoff between the latency
+Reviewed-by: Denis V. Lunev <den@openvz.org>
-increase while a request is queued and the cost of the io_submit(2)
+Message-id: 20220323114718.58714-2-philippe.mathieu.daude@gmail.com
 system call.
 Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
 Message-id: 20210721094211.69853-4-sgarzare@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/linux-aio.c | 9 ++++++++-
+ block/parallels-ext.c | 2 +-
-file changed, 8 insertions(+), 1 deletion(-)
+file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/block/linux-aio.c b/block/linux-aio.c
+diff --git a/block/parallels-ext.c b/block/parallels-ext.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/linux-aio.c
+--- a/block/parallels-ext.c
-+++ b/block/linux-aio.c
++++ b/block/parallels-ext.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int parallels_parse_format_extension(BlockDriverState *bs,
-  */
+             break;
- #define MAX_EVENTS 1024
+         default:
-+/* Maximum number of requests in a batch. (default value) */
+-            error_setg(errp, "Unknown feature: 0x%" PRIu64, fh.magic);
-+#define DEFAULT_MAX_BATCH 32
++            error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
-+
+             goto fail;
- struct qemu_laiocb {
+         }
      Coroutine *co;
      LinuxAioState *ctx;
@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
      LinuxAioState *s = laiocb->ctx;
      struct iocb *iocbs = &laiocb->iocb;
      QEMUIOVector *qiov = laiocb->qiov;
 +    int64_t max_batch = s->aio_context->aio_max_batch ?: DEFAULT_MAX_BATCH;
 +
 +    /* limit the batch with the number of available events */
 +    max_batch = MIN_NON_ZERO(MAX_EVENTS - s->io_q.in_flight, max_batch);
      switch (type) {
      case QEMU_AIO_WRITE:
@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
      s->io_q.in_queue++;
      if (!s->io_q.blocked &&
          (!s->io_q.plugged ||
 -         s->io_q.in_flight + s->io_q.in_queue >= MAX_EVENTS)) {
 +         s->io_q.in_queue >= max_batch)) {
          ioq_submit(s);
      }
 --
-.31.1
+.35.1

-[PULL for-6.1 1/3] iothread: generalize iothread_set_param/iothread_get_param
+[PULL for-7.0 2/2] hw: Fix misleading hexadecimal format
-From: Stefano Garzarella <sgarzare@redhat.com>
+From: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Changes in preparation for next patches where we add a new
+"0x%u" format is very misleading, replace by "0x%x".
 parameter not related to the poll mechanism.
-Let's add two new generic functions (iothread_set_param and
+Found running:
 iothread_get_param) that we use to set and get IOThread
 parameters.
-Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
+  $ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' hw/
-Message-id: 20210721094211.69853-2-sgarzare@redhat.com
 Inspired-by: Richard Henderson <richard.henderson@linaro.org>
 Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Message-id: 20220323114718.58714-3-philippe.mathieu.daude@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- iothread.c | 27 +++++++++++++++++++++++----
+ hw/i386/sgx.c        | 2 +-
-file changed, 23 insertions(+), 4 deletions(-)
+ hw/i386/trace-events | 6 +++---
  hw/misc/trace-events | 4 ++--
  hw/scsi/trace-events | 4 ++--
 files changed, 8 insertions(+), 8 deletions(-)
-diff --git a/iothread.c b/iothread.c
+diff --git a/hw/i386/sgx.c b/hw/i386/sgx.c
 index XXXXXXX..XXXXXXX 100644
---- a/iothread.c
+--- a/hw/i386/sgx.c
-+++ b/iothread.c
++++ b/hw/i386/sgx.c
-@@ -XXX,XX +XXX,XX @@ static PollParamInfo poll_shrink_info = {
+@@ -XXX,XX +XXX,XX @@ void pc_machine_init_sgx_epc(PCMachineState *pcms)
      "poll-shrink", offsetof(IOThread, poll_shrink),
  };
 -static void iothread_get_poll_param(Object *obj, Visitor *v,
 +static void iothread_get_param(Object *obj, Visitor *v,
          const char *name, void *opaque, Error **errp)
  {
      IOThread *iothread = IOTHREAD(obj);
@@ -XXX,XX +XXX,XX @@ static void iothread_get_poll_param(Object *obj, Visitor *v,
      visit_type_int64(v, name, field, errp);
  }
 -static void iothread_set_poll_param(Object *obj, Visitor *v,
 +static bool iothread_set_param(Object *obj, Visitor *v,
          const char *name, void *opaque, Error **errp)
  {
      IOThread *iothread = IOTHREAD(obj);
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
      int64_t value;
      if (!visit_type_int64(v, name, &value, errp)) {
 -        return;
 +        return false;
      }
-     if (value < 0) {
+     if ((sgx_epc->base + sgx_epc->size) < sgx_epc->base) {
-         error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
+-        error_report("Size of all 'sgx-epc' =0x%"PRIu64" causes EPC to wrap",
-                    info->name, INT64_MAX);
++        error_report("Size of all 'sgx-epc' =0x%"PRIx64" causes EPC to wrap",
--        return;
+                      sgx_epc->size);
-+        return false;
+         exit(EXIT_FAILURE);
      }
+diff --git a/hw/i386/trace-events b/hw/i386/trace-events
-     *field = value;
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/i386/trace-events
-+    return true;
++++ b/hw/i386/trace-events
-+}
+@@ -XXX,XX +XXX,XX @@ vtd_fault_disabled(void) "Fault processing disabled for context entry"
-+
+ vtd_replay_ce_valid(const char *mode, uint8_t bus, uint8_t dev, uint8_t fn, uint16_t domain, uint64_t hi, uint64_t lo) "%s: replay valid context device %02"PRIx8":%02"PRIx8".%02"PRIx8" domain 0x%"PRIx16" hi 0x%"PRIx64" lo 0x%"PRIx64
-+static void iothread_get_poll_param(Object *obj, Visitor *v,
+ vtd_replay_ce_invalid(uint8_t bus, uint8_t dev, uint8_t fn) "replay invalid context device %02"PRIx8":%02"PRIx8".%02"PRIx8
-+        const char *name, void *opaque, Error **errp)
+ vtd_page_walk_level(uint64_t addr, uint32_t level, uint64_t start, uint64_t end) "walk (base=0x%"PRIx64", level=%"PRIu32") iova range 0x%"PRIx64" - 0x%"PRIx64
-+{
+-vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIu16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
-+
++vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIx16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
-+    iothread_get_param(obj, v, name, opaque, errp);
+ vtd_page_walk_one_skip_map(uint64_t iova, uint64_t mask, uint64_t translated) "iova 0x%"PRIx64" mask 0x%"PRIx64" translated 0x%"PRIx64
-+}
+ vtd_page_walk_one_skip_unmap(uint64_t iova, uint64_t mask) "iova 0x%"PRIx64" mask 0x%"PRIx64
-+
+ vtd_page_walk_skip_read(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to unable to read"
-+static void iothread_set_poll_param(Object *obj, Visitor *v,
+ vtd_page_walk_skip_reserve(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to rsrv set"
-+        const char *name, void *opaque, Error **errp)
+ vtd_switch_address_space(uint8_t bus, uint8_t slot, uint8_t fn, bool on) "Device %02x:%02x.%x switching address space (iommu enabled=%d)"
-+{
+ vtd_as_unmap_whole(uint8_t bus, uint8_t slot, uint8_t fn, uint64_t iova, uint64_t size) "Device %02x:%02x.%x start 0x%"PRIx64" size 0x%"PRIx64
-+    IOThread *iothread = IOTHREAD(obj);
+-vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIu16", iova 0x%"PRIx64
-+
+-vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIu16" %d"
-+    if (!iothread_set_param(obj, v, name, opaque, errp)) {
++vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIx16", iova 0x%"PRIx64
-+        return;
++vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIx16" %d"
-+    }
+ vtd_irq_generate(uint64_t addr, uint64_t data) "addr 0x%"PRIx64" data 0x%"PRIx64
-+
+ vtd_reg_read(uint64_t addr, uint64_t size) "addr 0x%"PRIx64" size 0x%"PRIx64
-     if (iothread->ctx) {
+ vtd_reg_write(uint64_t addr, uint64_t size, uint64_t val) "addr 0x%"PRIx64" size 0x%"PRIx64" value 0x%"PRIx64
-         aio_context_set_poll_params(iothread->ctx,
+diff --git a/hw/misc/trace-events b/hw/misc/trace-events
-                                     iothread->poll_max_ns,
+index XXXXXXX..XXXXXXX 100644
 --- a/hw/misc/trace-events
 +++ b/hw/misc/trace-events
@@ -XXX,XX +XXX,XX @@
  # See docs/devel/tracing.rst for syntax documentation.
  # allwinner-cpucfg.c
 -allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIu32
 +allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIx32
  allwinner_cpucfg_read(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
  allwinner_cpucfg_write(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
@@ -XXX,XX +XXX,XX @@ imx7_gpr_write(uint64_t offset, uint64_t value) "addr 0x%08" PRIx64 "value 0x%08
  # mos6522.c
  mos6522_set_counter(int index, unsigned int val) "T%d.counter=%d"
 -mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRId64 " delta_next=0x%"PRId64
 +mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRIx64 " delta_next=0x%"PRIx64
  mos6522_set_sr_int(void) "set sr_int"
  mos6522_write(uint64_t addr, const char *name, uint64_t val) "reg=0x%"PRIx64 " [%s] val=0x%"PRIx64
  mos6522_read(uint64_t addr, const char *name, unsigned val) "reg=0x%"PRIx64 " [%s] val=0x%x"
 diff --git a/hw/scsi/trace-events b/hw/scsi/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/scsi/trace-events
 +++ b/hw/scsi/trace-events
@@ -XXX,XX +XXX,XX @@ lsi_bad_phase_interrupt(void) "Phase mismatch interrupt"
  lsi_bad_selection(uint32_t id) "Selected absent target %"PRIu32
  lsi_do_dma_unavailable(void) "DMA no data available"
  lsi_do_dma(uint64_t addr, int len) "DMA addr=0x%"PRIx64" len=%d"
 -lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRId32
 +lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRIx32
  lsi_add_msg_byte_error(void) "MSG IN data too long"
  lsi_add_msg_byte(uint8_t data) "MSG IN 0x%02x"
  lsi_reselect(int id) "Reselected target %d"
@@ -XXX,XX +XXX,XX @@ lsi_do_msgout_noop(void) "MSG: No Operation"
  lsi_do_msgout_extended(uint8_t msg, uint8_t len) "Extended message 0x%x (len %d)"
  lsi_do_msgout_ignored(const char *msg) "%s (ignored)"
  lsi_do_msgout_simplequeue(uint8_t select_tag) "SIMPLE queue tag=0x%x"
 -lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRId32
 +lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRIx32
  lsi_do_msgout_clearqueue(uint32_t tag) "MSG: CLEAR QUEUE tag=0x%"PRIx32
  lsi_do_msgout_busdevicereset(uint32_t tag) "MSG: BUS DEVICE RESET tag=0x%"PRIx32
  lsi_do_msgout_select(int id) "Select LUN %d"
 --
-.31.1
+.35.1

-[PULL for-6.1 2/3] iothread: add aio-max-batch parameter
+Deleted patch
-From: Stefano Garzarella <sgarzare@redhat.com>
-The `aio-max-batch` parameter will be propagated to AIO engines
-and it will be used to control the maximum number of queued requests.
-When there are in queue a number of requests equal to `aio-max-batch`,
-the engine invokes the system call to forward the requests to the kernel.
-This parameter allows us to control the maximum batch size to reduce
-the latency that requests might accumulate while queued in the AIO
-engine queue.
-If `aio-max-batch` is equal to 0 (default value), the AIO engine will
-use its default maximum batch size value.
-Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
-Message-id: 20210721094211.69853-3-sgarzare@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- qapi/misc.json            |  6 ++++-
- qapi/qom.json             |  7 ++++-
- include/block/aio.h       | 12 +++++++++
- include/sysemu/iothread.h |  3 +++
- iothread.c                | 55 +++++++++++++++++++++++++++++++++++----
- monitor/hmp-cmds.c        |  2 ++
- util/aio-posix.c          | 12 +++++++++
- util/aio-win32.c          |  5 ++++
- util/async.c              |  2 ++
- qemu-options.hx           |  8 ++++--
-files changed, 103 insertions(+), 9 deletions(-)
-diff --git a/qapi/misc.json b/qapi/misc.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/misc.json
-+++ b/qapi/misc.json
-@@ -XXX,XX +XXX,XX @@
- # @poll-shrink: how many ns will be removed from polling time, 0 means that
- #               it's not configured (since 2.9)
- #
-+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
-+#                 0 means that the engine will use its default (since 6.1)
-+#
- # Since: 2.0
- ##
- { 'struct': 'IOThreadInfo',
-@@ -XXX,XX +XXX,XX @@
-            'thread-id': 'int',
-            'poll-max-ns': 'int',
-            'poll-grow': 'int',
--           'poll-shrink': 'int' } }
-+           'poll-shrink': 'int',
-+           'aio-max-batch': 'int' } }
- ##
- # @query-iothreads:
-diff --git a/qapi/qom.json b/qapi/qom.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/qom.json
-+++ b/qapi/qom.json
-@@ -XXX,XX +XXX,XX @@
- #               algorithm detects it is spending too long polling without
- #               encountering events. 0 selects a default behaviour (default: 0)
- #
-+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
-+#                 0 means that the engine will use its default
-+#                 (default:0, since 6.1)
-+#
- # Since: 2.0
- ##
- { 'struct': 'IothreadProperties',
-   'data': { '*poll-max-ns': 'int',
-             '*poll-grow': 'int',
--            '*poll-shrink': 'int' } }
-+            '*poll-shrink': 'int',
-+            '*aio-max-batch': 'int' } }
- ##
- # @MemoryBackendProperties:
-diff --git a/include/block/aio.h b/include/block/aio.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/aio.h
-+++ b/include/block/aio.h
-@@ -XXX,XX +XXX,XX @@ struct AioContext {
-     int64_t poll_grow;      /* polling time growth factor */
-     int64_t poll_shrink;    /* polling time shrink factor */
-+    /* AIO engine parameters */
-+    int64_t aio_max_batch;  /* maximum number of requests in a batch */
-+
-     /*
-      * List of handlers participating in userspace polling.  Protected by
-      * ctx->list_lock.  Iterated and modified mostly by the event loop thread
-@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
-                                  int64_t grow, int64_t shrink,
-                                  Error **errp);
-+/**
-+ * aio_context_set_aio_params:
-+ * @ctx: the aio context
-+ * @max_batch: maximum number of requests in a batch, 0 means that the
-+ *             engine will use its default
-+ */
-+void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
-+                                Error **errp);
-+
- #endif
-diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/sysemu/iothread.h
-+++ b/include/sysemu/iothread.h
-@@ -XXX,XX +XXX,XX @@ struct IOThread {
-     int64_t poll_max_ns;
-     int64_t poll_grow;
-     int64_t poll_shrink;
-+
-+    /* AioContext AIO engine parameters */
-+    int64_t aio_max_batch;
- };
- typedef struct IOThread IOThread;
-diff --git a/iothread.c b/iothread.c
-index XXXXXXX..XXXXXXX 100644
---- a/iothread.c
-+++ b/iothread.c
-@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
-     iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
- }
-+static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
-+{
-+    ERRP_GUARD();
-+
-+    aio_context_set_poll_params(iothread->ctx,
-+                                iothread->poll_max_ns,
-+                                iothread->poll_grow,
-+                                iothread->poll_shrink,
-+                                errp);
-+    if (*errp) {
-+        return;
-+    }
-+
-+    aio_context_set_aio_params(iothread->ctx,
-+                               iothread->aio_max_batch,
-+                               errp);
-+}
-+
- static void iothread_complete(UserCreatable *obj, Error **errp)
- {
-     Error *local_error = NULL;
-@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
-      */
-     iothread_init_gcontext(iothread);
--    aio_context_set_poll_params(iothread->ctx,
--                                iothread->poll_max_ns,
--                                iothread->poll_grow,
--                                iothread->poll_shrink,
--                                &local_error);
-+    iothread_set_aio_context_params(iothread, &local_error);
-     if (local_error) {
-         error_propagate(errp, local_error);
-         aio_context_unref(iothread->ctx);
-@@ -XXX,XX +XXX,XX @@ static PollParamInfo poll_grow_info = {
- static PollParamInfo poll_shrink_info = {
-     "poll-shrink", offsetof(IOThread, poll_shrink),
- };
-+static PollParamInfo aio_max_batch_info = {
-+    "aio-max-batch", offsetof(IOThread, aio_max_batch),
-+};
- static void iothread_get_param(Object *obj, Visitor *v,
-         const char *name, void *opaque, Error **errp)
-@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
-     }
- }
-+static void iothread_get_aio_param(Object *obj, Visitor *v,
-+        const char *name, void *opaque, Error **errp)
-+{
-+
-+    iothread_get_param(obj, v, name, opaque, errp);
-+}
-+
-+static void iothread_set_aio_param(Object *obj, Visitor *v,
-+        const char *name, void *opaque, Error **errp)
-+{
-+    IOThread *iothread = IOTHREAD(obj);
-+
-+    if (!iothread_set_param(obj, v, name, opaque, errp)) {
-+        return;
-+    }
-+
-+    if (iothread->ctx) {
-+        aio_context_set_aio_params(iothread->ctx,
-+                                   iothread->aio_max_batch,
-+                                   errp);
-+    }
-+}
-+
- static void iothread_class_init(ObjectClass *klass, void *class_data)
- {
-     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
-                               iothread_get_poll_param,
-                               iothread_set_poll_param,
-                               NULL, &poll_shrink_info);
-+    object_class_property_add(klass, "aio-max-batch", "int",
-+                              iothread_get_aio_param,
-+                              iothread_set_aio_param,
-+                              NULL, &aio_max_batch_info);
- }
- static const TypeInfo iothread_info = {
-@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
-     info->poll_max_ns = iothread->poll_max_ns;
-     info->poll_grow = iothread->poll_grow;
-     info->poll_shrink = iothread->poll_shrink;
-+    info->aio_max_batch = iothread->aio_max_batch;
-     QAPI_LIST_APPEND(*tail, info);
-     return 0;
-diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
-index XXXXXXX..XXXXXXX 100644
---- a/monitor/hmp-cmds.c
-+++ b/monitor/hmp-cmds.c
-@@ -XXX,XX +XXX,XX @@ void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
-         monitor_printf(mon, "  poll-max-ns=%" PRId64 "\n", value->poll_max_ns);
-         monitor_printf(mon, "  poll-grow=%" PRId64 "\n", value->poll_grow);
-         monitor_printf(mon, "  poll-shrink=%" PRId64 "\n", value->poll_shrink);
-+        monitor_printf(mon, "  aio-max-batch=%" PRId64 "\n",
-+                       value->aio_max_batch);
-     }
-     qapi_free_IOThreadInfoList(info_list);
-diff --git a/util/aio-posix.c b/util/aio-posix.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/aio-posix.c
-+++ b/util/aio-posix.c
-@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
-     aio_notify(ctx);
- }
-+
-+void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
-+                                Error **errp)
-+{
-+    /*
-+     * No thread synchronization here, it doesn't matter if an incorrect value
-+     * is used once.
-+     */
-+    ctx->aio_max_batch = max_batch;
-+
-+    aio_notify(ctx);
-+}
-diff --git a/util/aio-win32.c b/util/aio-win32.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/aio-win32.c
-+++ b/util/aio-win32.c
-@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
-         error_setg(errp, "AioContext polling is not implemented on Windows");
-     }
- }
-+
-+void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
-+                                Error **errp)
-+{
-+}
-diff --git a/util/async.c b/util/async.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/async.c
-+++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
-     ctx->poll_grow = 0;
-     ctx->poll_shrink = 0;
-+    ctx->aio_max_batch = 0;
-+
-     return ctx;
- fail:
-     g_source_destroy(&ctx->source);
-diff --git a/qemu-options.hx b/qemu-options.hx
-index XXXXXXX..XXXXXXX 100644
---- a/qemu-options.hx
-+++ b/qemu-options.hx
-@@ -XXX,XX +XXX,XX @@ SRST
-             CN=laptop.example.com,O=Example Home,L=London,ST=London,C=GB
--    ``-object iothread,id=id,poll-max-ns=poll-max-ns,poll-grow=poll-grow,poll-shrink=poll-shrink``
-+    ``-object iothread,id=id,poll-max-ns=poll-max-ns,poll-grow=poll-grow,poll-shrink=poll-shrink,aio-max-batch=aio-max-batch``
-         Creates a dedicated event loop thread that devices can be
-         assigned to. This is known as an IOThread. By default device
-         emulation happens in vCPU threads or the main event loop thread.
-@@ -XXX,XX +XXX,XX @@ SRST
-         the polling time when the algorithm detects it is spending too
-         long polling without encountering events.
--        The polling parameters can be modified at run-time using the
-+        The ``aio-max-batch`` parameter is the maximum number of requests
-+        in a batch for the AIO engine, 0 means that the engine will use
-+        its default.
-+
-+        The IOThread parameters can be modified at run-time using the
-         ``qom-set`` command (where ``iothread1`` is the IOThread's
-         ``id``):
---
-.31.1

The following changes since commit 801f3db7564dcce8a37a70833c0abe40ec19f8ce:

Merge remote-tracking branch 'remotes/philmd/tags/kconfig-20210720' into staging (2021-07-20 19:30:28 +0100)

are available in the Git repository at:

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

for you to fetch changes up to d7ddd0a1618a75b31dc308bb37365ce1da972154:

linux-aio: limit the batch size using `aio-max-batch` parameter (2021-07-21 13:47:50 +0100)

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

Stefano's performance regression fix for commit 2558cb8dd4 ("linux-aio:
increasing MAX_EVENTS to a larger hardcoded value").

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

Stefano Garzarella (3):
  iothread: generalize iothread_set_param/iothread_get_param
  iothread: add aio-max-batch parameter
  linux-aio: limit the batch size using `aio-max-batch` parameter

-- 
2.31.1

From: Stefano Garzarella <sgarzare@redhat.com>

Changes in preparation for next patches where we add a new
parameter not related to the poll mechanism.

Let's add two new generic functions (iothread_set_param and
iothread_get_param) that we use to set and get IOThread
parameters.

Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20210721094211.69853-2-sgarzare@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 iothread.c | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static PollParamInfo poll_shrink_info = {
     "poll-shrink", offsetof(IOThread, poll_shrink),
 };
 
-static void iothread_get_poll_param(Object *obj, Visitor *v,
+static void iothread_get_param(Object *obj, Visitor *v,
         const char *name, void *opaque, Error **errp)
 {
     IOThread *iothread = IOTHREAD(obj);
@@ -XXX,XX +XXX,XX @@ static void iothread_get_poll_param(Object *obj, Visitor *v,
     visit_type_int64(v, name, field, errp);
 }
 
-static void iothread_set_poll_param(Object *obj, Visitor *v,
+static bool iothread_set_param(Object *obj, Visitor *v,
         const char *name, void *opaque, Error **errp)
 {
     IOThread *iothread = IOTHREAD(obj);
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
     int64_t value;
 
     if (!visit_type_int64(v, name, &value, errp)) {
-        return;
+        return false;
     }
 
     if (value < 0) {
         error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
                    info->name, INT64_MAX);
-        return;
+        return false;
     }
 
     *field = value;
 
+    return true;
+}
+
+static void iothread_get_poll_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+
+    iothread_get_param(obj, v, name, opaque, errp);
+}
+
+static void iothread_set_poll_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    IOThread *iothread = IOTHREAD(obj);
+
+    if (!iothread_set_param(obj, v, name, opaque, errp)) {
+        return;
+    }
+
     if (iothread->ctx) {
         aio_context_set_poll_params(iothread->ctx,
                                     iothread->poll_max_ns,
-- 
2.31.1

From: Stefano Garzarella <sgarzare@redhat.com>

The `aio-max-batch` parameter will be propagated to AIO engines
and it will be used to control the maximum number of queued requests.

When there are in queue a number of requests equal to `aio-max-batch`,
the engine invokes the system call to forward the requests to the kernel.

This parameter allows us to control the maximum batch size to reduce
the latency that requests might accumulate while queued in the AIO
engine queue.

If `aio-max-batch` is equal to 0 (default value), the AIO engine will
use its default maximum batch size value.

Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20210721094211.69853-3-sgarzare@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/misc.json            |  6 ++++-
 qapi/qom.json             |  7 ++++-
 include/block/aio.h       | 12 +++++++++
 include/sysemu/iothread.h |  3 +++
 iothread.c                | 55 +++++++++++++++++++++++++++++++++++----
 monitor/hmp-cmds.c        |  2 ++
 util/aio-posix.c          | 12 +++++++++
 util/aio-win32.c          |  5 ++++
 util/async.c              |  2 ++
 qemu-options.hx           |  8 ++++--
 10 files changed, 103 insertions(+), 9 deletions(-)

diff --git a/qapi/misc.json b/qapi/misc.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/misc.json
+++ b/qapi/misc.json
@@ -XXX,XX +XXX,XX @@
 # @poll-shrink: how many ns will be removed from polling time, 0 means that
 #               it's not configured (since 2.9)
 #
+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
+#                 0 means that the engine will use its default (since 6.1)
+#
 # Since: 2.0
 ##
 { 'struct': 'IOThreadInfo',
@@ -XXX,XX +XXX,XX @@
            'thread-id': 'int',
            'poll-max-ns': 'int',
            'poll-grow': 'int',
-           'poll-shrink': 'int' } }
+           'poll-shrink': 'int',
+           'aio-max-batch': 'int' } }
 
 ##
 # @query-iothreads:
diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
 #               algorithm detects it is spending too long polling without
 #               encountering events. 0 selects a default behaviour (default: 0)
 #
+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
+#                 0 means that the engine will use its default
+#                 (default:0, since 6.1)
+#
 # Since: 2.0
 ##
 { 'struct': 'IothreadProperties',
   'data': { '*poll-max-ns': 'int',
             '*poll-grow': 'int',
-            '*poll-shrink': 'int' } }
+            '*poll-shrink': 'int',
+            '*aio-max-batch': 'int' } }
 
 ##
 # @MemoryBackendProperties:
diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ struct AioContext {
     int64_t poll_grow;      /* polling time growth factor */
     int64_t poll_shrink;    /* polling time shrink factor */
 
+    /* AIO engine parameters */
+    int64_t aio_max_batch;  /* maximum number of requests in a batch */
+
     /*
      * List of handlers participating in userspace polling.  Protected by
      * ctx->list_lock.  Iterated and modified mostly by the event loop thread
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
                                  int64_t grow, int64_t shrink,
                                  Error **errp);
 
+/**
+ * aio_context_set_aio_params:
+ * @ctx: the aio context
+ * @max_batch: maximum number of requests in a batch, 0 means that the
+ *             engine will use its default
+ */
+void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
+                                Error **errp);
+
 #endif
diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/iothread.h
+++ b/include/sysemu/iothread.h
@@ -XXX,XX +XXX,XX @@ struct IOThread {
     int64_t poll_max_ns;
     int64_t poll_grow;
     int64_t poll_shrink;
+
+    /* AioContext AIO engine parameters */
+    int64_t aio_max_batch;
 };
 typedef struct IOThread IOThread;
 
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
     iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
 }
 
+static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
+{
+    ERRP_GUARD();
+
+    aio_context_set_poll_params(iothread->ctx,
+                                iothread->poll_max_ns,
+                                iothread->poll_grow,
+                                iothread->poll_shrink,
+                                errp);
+    if (*errp) {
+        return;
+    }
+
+    aio_context_set_aio_params(iothread->ctx,
+                               iothread->aio_max_batch,
+                               errp);
+}
+
 static void iothread_complete(UserCreatable *obj, Error **errp)
 {
     Error *local_error = NULL;
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
      */
     iothread_init_gcontext(iothread);
 
-    aio_context_set_poll_params(iothread->ctx,
-                                iothread->poll_max_ns,
-                                iothread->poll_grow,
-                                iothread->poll_shrink,
-                                &local_error);
+    iothread_set_aio_context_params(iothread, &local_error);
     if (local_error) {
         error_propagate(errp, local_error);
         aio_context_unref(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static PollParamInfo poll_grow_info = {
 static PollParamInfo poll_shrink_info = {
     "poll-shrink", offsetof(IOThread, poll_shrink),
 };
+static PollParamInfo aio_max_batch_info = {
+    "aio-max-batch", offsetof(IOThread, aio_max_batch),
+};
 
 static void iothread_get_param(Object *obj, Visitor *v,
         const char *name, void *opaque, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
     }
 }
 
+static void iothread_get_aio_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+
+    iothread_get_param(obj, v, name, opaque, errp);
+}
+
+static void iothread_set_aio_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    IOThread *iothread = IOTHREAD(obj);
+
+    if (!iothread_set_param(obj, v, name, opaque, errp)) {
+        return;
+    }
+
+    if (iothread->ctx) {
+        aio_context_set_aio_params(iothread->ctx,
+                                   iothread->aio_max_batch,
+                                   errp);
+    }
+}
+
 static void iothread_class_init(ObjectClass *klass, void *class_data)
 {
     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
                               iothread_get_poll_param,
                               iothread_set_poll_param,
                               NULL, &poll_shrink_info);
+    object_class_property_add(klass, "aio-max-batch", "int",
+                              iothread_get_aio_param,
+                              iothread_set_aio_param,
+                              NULL, &aio_max_batch_info);
 }
 
 static const TypeInfo iothread_info = {
@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
     info->poll_max_ns = iothread->poll_max_ns;
     info->poll_grow = iothread->poll_grow;
     info->poll_shrink = iothread->poll_shrink;
+    info->aio_max_batch = iothread->aio_max_batch;
 
     QAPI_LIST_APPEND(*tail, info);
     return 0;
diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/monitor/hmp-cmds.c
+++ b/monitor/hmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
         monitor_printf(mon, "  poll-max-ns=%" PRId64 "\n", value->poll_max_ns);
         monitor_printf(mon, "  poll-grow=%" PRId64 "\n", value->poll_grow);
         monitor_printf(mon, "  poll-shrink=%" PRId64 "\n", value->poll_shrink);
+        monitor_printf(mon, "  aio-max-batch=%" PRId64 "\n",
+                       value->aio_max_batch);
     }
 
     qapi_free_IOThreadInfoList(info_list);
diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
 
     aio_notify(ctx);
 }
+
+void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
+                                Error **errp)
+{
+    /*
+     * No thread synchronization here, it doesn't matter if an incorrect value
+     * is used once.
+     */
+    ctx->aio_max_batch = max_batch;
+
+    aio_notify(ctx);
+}
diff --git a/util/aio-win32.c b/util/aio-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-win32.c
+++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
         error_setg(errp, "AioContext polling is not implemented on Windows");
     }
 }
+
+void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
+                                Error **errp)
+{
+}
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
     ctx->poll_grow = 0;
     ctx->poll_shrink = 0;
 
+    ctx->aio_max_batch = 0;
+
     return ctx;
 fail:
     g_source_destroy(&ctx->source);
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ SRST
 
             CN=laptop.example.com,O=Example Home,L=London,ST=London,C=GB
 
-    ``-object iothread,id=id,poll-max-ns=poll-max-ns,poll-grow=poll-grow,poll-shrink=poll-shrink``
+    ``-object iothread,id=id,poll-max-ns=poll-max-ns,poll-grow=poll-grow,poll-shrink=poll-shrink,aio-max-batch=aio-max-batch``
         Creates a dedicated event loop thread that devices can be
         assigned to. This is known as an IOThread. By default device
         emulation happens in vCPU threads or the main event loop thread.
@@ -XXX,XX +XXX,XX @@ SRST
         the polling time when the algorithm detects it is spending too
         long polling without encountering events.
 
-        The polling parameters can be modified at run-time using the
+        The ``aio-max-batch`` parameter is the maximum number of requests
+        in a batch for the AIO engine, 0 means that the engine will use
+        its default.
+
+        The IOThread parameters can be modified at run-time using the
         ``qom-set`` command (where ``iothread1`` is the IOThread's
         ``id``):
 
-- 
2.31.1

From: Stefano Garzarella <sgarzare@redhat.com>

When there are multiple queues attached to the same AIO context,
some requests may experience high latency, since in the worst case
the AIO engine queue is only flushed when it is full (MAX_EVENTS) or
there are no more queues plugged.

Commit 2558cb8dd4 ("linux-aio: increasing MAX_EVENTS to a larger
hardcoded value") changed MAX_EVENTS from 128 to 1024, to increase
the number of in-flight requests. But this change also increased
the potential maximum batch to 1024 elements.

When there is a single queue attached to the AIO context, the issue
is mitigated from laio_io_unplug() that will flush the queue every
time is invoked since there can't be others queue plugged.

Let's use the new `aio-max-batch` IOThread parameter to mitigate
this issue, limiting the number of requests in a batch.

We also define a default value (32): this value is obtained running
some benchmarks and it represents a good tradeoff between the latency
increase while a request is queued and the cost of the io_submit(2)
system call.

Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20210721094211.69853-4-sgarzare@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/linux-aio.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/block/linux-aio.c b/block/linux-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@
  */
 #define MAX_EVENTS 1024
 
+/* Maximum number of requests in a batch. (default value) */
+#define DEFAULT_MAX_BATCH 32
+
 struct qemu_laiocb {
     Coroutine *co;
     LinuxAioState *ctx;
@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
     LinuxAioState *s = laiocb->ctx;
     struct iocb *iocbs = &laiocb->iocb;
     QEMUIOVector *qiov = laiocb->qiov;
+    int64_t max_batch = s->aio_context->aio_max_batch ?: DEFAULT_MAX_BATCH;
+
+    /* limit the batch with the number of available events */
+    max_batch = MIN_NON_ZERO(MAX_EVENTS - s->io_q.in_flight, max_batch);
 
     switch (type) {
     case QEMU_AIO_WRITE:
@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
     s->io_q.in_queue++;
     if (!s->io_q.blocked &&
         (!s->io_q.plugged ||
-         s->io_q.in_flight + s->io_q.in_queue >= MAX_EVENTS)) {
+         s->io_q.in_queue >= max_batch)) {
         ioq_submit(s);
     }
 
-- 
2.31.1

The following changes since commit 15ef89d2a1a7b93845a6b09c2ee8e1979f6eb30b:

Update version for v7.0.0-rc1 release (2022-03-22 22:58:44 +0000)

are available in the Git repository at:

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

for you to fetch changes up to 2539eade4f689eda7e9fe45486f18334bfbafaf0:

hw: Fix misleading hexadecimal format (2022-03-24 10:38:42 +0000)

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

Philippe found cases where the 0x%d format string was used, leading to
misleading output. The patches look harmless and could save people time, so I
think it's worth including them in 7.0.

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

Philippe Mathieu-Daudé (2):
  block: Fix misleading hexadecimal format
  hw: Fix misleading hexadecimal format

-- 
2.35.1

From: Philippe Mathieu-Daudé <f4bug@amsat.org>

"0x%u" format is very misleading, replace by "0x%x".

Found running:

$ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' block/

Inspired-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Denis V. Lunev <den@openvz.org>
Message-id: 20220323114718.58714-2-philippe.mathieu.daude@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/parallels-ext.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/parallels-ext.c b/block/parallels-ext.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels-ext.c
+++ b/block/parallels-ext.c
@@ -XXX,XX +XXX,XX @@ static int parallels_parse_format_extension(BlockDriverState *bs,
             break;
 
         default:
-            error_setg(errp, "Unknown feature: 0x%" PRIu64, fh.magic);
+            error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
             goto fail;
         }
 
-- 
2.35.1

From: Philippe Mathieu-Daudé <f4bug@amsat.org>

"0x%u" format is very misleading, replace by "0x%x".

Found running:

$ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' hw/

Inspired-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Message-id: 20220323114718.58714-3-philippe.mathieu.daude@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/i386/sgx.c        | 2 +-
 hw/i386/trace-events | 6 +++---
 hw/misc/trace-events | 4 ++--
 hw/scsi/trace-events | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/hw/i386/sgx.c b/hw/i386/sgx.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/i386/sgx.c
+++ b/hw/i386/sgx.c
@@ -XXX,XX +XXX,XX @@ void pc_machine_init_sgx_epc(PCMachineState *pcms)
     }
 
     if ((sgx_epc->base + sgx_epc->size) < sgx_epc->base) {
-        error_report("Size of all 'sgx-epc' =0x%"PRIu64" causes EPC to wrap",
+        error_report("Size of all 'sgx-epc' =0x%"PRIx64" causes EPC to wrap",
                      sgx_epc->size);
         exit(EXIT_FAILURE);
     }
diff --git a/hw/i386/trace-events b/hw/i386/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/i386/trace-events
+++ b/hw/i386/trace-events
@@ -XXX,XX +XXX,XX @@ vtd_fault_disabled(void) "Fault processing disabled for context entry"
 vtd_replay_ce_valid(const char *mode, uint8_t bus, uint8_t dev, uint8_t fn, uint16_t domain, uint64_t hi, uint64_t lo) "%s: replay valid context device %02"PRIx8":%02"PRIx8".%02"PRIx8" domain 0x%"PRIx16" hi 0x%"PRIx64" lo 0x%"PRIx64
 vtd_replay_ce_invalid(uint8_t bus, uint8_t dev, uint8_t fn) "replay invalid context device %02"PRIx8":%02"PRIx8".%02"PRIx8
 vtd_page_walk_level(uint64_t addr, uint32_t level, uint64_t start, uint64_t end) "walk (base=0x%"PRIx64", level=%"PRIu32") iova range 0x%"PRIx64" - 0x%"PRIx64
-vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIu16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
+vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIx16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
 vtd_page_walk_one_skip_map(uint64_t iova, uint64_t mask, uint64_t translated) "iova 0x%"PRIx64" mask 0x%"PRIx64" translated 0x%"PRIx64
 vtd_page_walk_one_skip_unmap(uint64_t iova, uint64_t mask) "iova 0x%"PRIx64" mask 0x%"PRIx64
 vtd_page_walk_skip_read(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to unable to read"
 vtd_page_walk_skip_reserve(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to rsrv set"
 vtd_switch_address_space(uint8_t bus, uint8_t slot, uint8_t fn, bool on) "Device %02x:%02x.%x switching address space (iommu enabled=%d)"
 vtd_as_unmap_whole(uint8_t bus, uint8_t slot, uint8_t fn, uint64_t iova, uint64_t size) "Device %02x:%02x.%x start 0x%"PRIx64" size 0x%"PRIx64
-vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIu16", iova 0x%"PRIx64
-vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIu16" %d"
+vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIx16", iova 0x%"PRIx64
+vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIx16" %d"
 vtd_irq_generate(uint64_t addr, uint64_t data) "addr 0x%"PRIx64" data 0x%"PRIx64
 vtd_reg_read(uint64_t addr, uint64_t size) "addr 0x%"PRIx64" size 0x%"PRIx64
 vtd_reg_write(uint64_t addr, uint64_t size, uint64_t val) "addr 0x%"PRIx64" size 0x%"PRIx64" value 0x%"PRIx64
diff --git a/hw/misc/trace-events b/hw/misc/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/misc/trace-events
+++ b/hw/misc/trace-events
@@ -XXX,XX +XXX,XX @@
 # See docs/devel/tracing.rst for syntax documentation.
 
 # allwinner-cpucfg.c
-allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIu32
+allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIx32
 allwinner_cpucfg_read(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
 allwinner_cpucfg_write(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
 
@@ -XXX,XX +XXX,XX @@ imx7_gpr_write(uint64_t offset, uint64_t value) "addr 0x%08" PRIx64 "value 0x%08
 
 # mos6522.c
 mos6522_set_counter(int index, unsigned int val) "T%d.counter=%d"
-mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRId64 " delta_next=0x%"PRId64
+mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRIx64 " delta_next=0x%"PRIx64
 mos6522_set_sr_int(void) "set sr_int"
 mos6522_write(uint64_t addr, const char *name, uint64_t val) "reg=0x%"PRIx64 " [%s] val=0x%"PRIx64
 mos6522_read(uint64_t addr, const char *name, unsigned val) "reg=0x%"PRIx64 " [%s] val=0x%x"
diff --git a/hw/scsi/trace-events b/hw/scsi/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/trace-events
+++ b/hw/scsi/trace-events
@@ -XXX,XX +XXX,XX @@ lsi_bad_phase_interrupt(void) "Phase mismatch interrupt"
 lsi_bad_selection(uint32_t id) "Selected absent target %"PRIu32
 lsi_do_dma_unavailable(void) "DMA no data available"
 lsi_do_dma(uint64_t addr, int len) "DMA addr=0x%"PRIx64" len=%d"
-lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRId32
+lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRIx32
 lsi_add_msg_byte_error(void) "MSG IN data too long"
 lsi_add_msg_byte(uint8_t data) "MSG IN 0x%02x"
 lsi_reselect(int id) "Reselected target %d"
@@ -XXX,XX +XXX,XX @@ lsi_do_msgout_noop(void) "MSG: No Operation"
 lsi_do_msgout_extended(uint8_t msg, uint8_t len) "Extended message 0x%x (len %d)"
 lsi_do_msgout_ignored(const char *msg) "%s (ignored)"
 lsi_do_msgout_simplequeue(uint8_t select_tag) "SIMPLE queue tag=0x%x"
-lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRId32
+lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRIx32
 lsi_do_msgout_clearqueue(uint32_t tag) "MSG: CLEAR QUEUE tag=0x%"PRIx32
 lsi_do_msgout_busdevicereset(uint32_t tag) "MSG: BUS DEVICE RESET tag=0x%"PRIx32
 lsi_do_msgout_select(int id) "Select LUN %d"
-- 
2.35.1