Register I/O requests to BlockBackends with a per-BB timer running in
the background (in the main context) that goes through the list of
requests to find any that surpass a user-defined[1] threshold and then
emit a QMP event calling this out, or stopping the VM altogether so the
guest can be shielded of absolutely excessive delay.
One example for where stopping may be useful: Windows will cancel
requests after a set timeout, but virtio-blk does not support cancelling
requests (by design, I understand). So it will cancel again, and again,
and then reset the whole driver (which however won’t cancel the request
either), and eventually declare the driver faulty and show a BSOD. The
only ways around this would be to implement request cancellation (which
I think is not generally possible), or, well, pause the VM in case of
absolutely excessive I/O request delay, and resume it when the request
is done (BLOCK_IO_DONE event), so that Windows will not see that massive
delay.
[1] Not yet user-defined in this commit, but a future commit will allow
users to specify the threshold when to take action, on the guest
device.
Signed-off-by: Hanna Czenczek <[email protected]>
---
include/block/block-backend-delay.h | 112 +++++++
include/system/block-backend-global-state.h | 11 +
block/block-backend-delay.c | 326 ++++++++++++++++++++
block/block-backend.c | 44 ++-
block/meson.build | 1 +
5 files changed, 492 insertions(+), 2 deletions(-)
create mode 100644 include/block/block-backend-delay.h
create mode 100644 block/block-backend-delay.c
diff --git a/include/block/block-backend-delay.h
b/include/block/block-backend-delay.h
new file mode 100644
index 00000000000..9af2e6de925
--- /dev/null
+++ b/include/block/block-backend-delay.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026 Hanna Czenczek <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef BLOCK_BACKEND_DELAY_H
+#define BLOCK_BACKEND_DELAY_H
+
+#include "qemu/thread.h"
+#include "qemu/timer.h"
+#include "qapi/qapi-types-block.h"
+
+/* Enumeration of I/O delay threshold types */
+enum BlockDelayThreshold {
+ /* Latency threshold at which to report a delay */
+ BLOCK_DELAY_REPORT,
+ /* Latency threshold at which to auto-stop the VM */
+ BLOCK_DELAY_STOP,
+
+ /* Number of different thresholds */
+ BLOCK_DELAY__MAX,
+};
+
+typedef struct BlockDelayTracker {
+ /* Timer to regularly check requests for delay */
+ QEMUTimer *timer;
+
+ /* Which clock to use */
+ QEMUClockType clock_type;
+
+ /*
+ * Protects access to all subsequent fields in this struct. Do not take any
+ * other lock while this lock is taken.
+ */
+ QemuMutex lock;
+
+ /* Thresholds for generating delay report events or stopping the VM */
+ uint64_t threshold_ns[BLOCK_DELAY__MAX];
+
+ /* List of active requests; new requests appended at the end */
+ QTAILQ_HEAD(, BlockDelayTrackerRequest) requests;
+} BlockDelayTracker;
+
+typedef struct BlockDelayTrackerRequest {
+ /* offset < 0 means no valid offset */
+ int64_t offset;
+ /* Request length, or 0 if no valid length */
+ uint64_t bytes;
+ /* When the request was started */
+ uint64_t start_time_ns;
+ /* Operation type */
+ IoAccountingOperation op_type;
+ /*
+ * Whether any delay threshold has been exceeded.
+ * If so, we need to emit BLOCK_IO_DONE when the request is done.
+ */
+ bool threshold_exceeded[BLOCK_DELAY__MAX];
+ /*
+ * Set the first time any threshold is exceeded, to cache the device name
+ * for BLOCK_IO_DONE.
+ */
+ char *device_path;
+
+ /* Entry in the list of all running requests for this BB */
+ QTAILQ_ENTRY(BlockDelayTrackerRequest) list;
+} BlockDelayTrackerRequest;
+
+/**
+ * Set up the request latency delay tracker for this BlockBackend.
+ *
+ * The caller must allocate blk->delay_tracker beforehand (because
+ * block-backend-delay.c cannot access BlockBackend fields directly).
+ */
+void blk_delay_tracker_init(BlockBackend *blk);
+
+/**
+ * Stop and destroy the request latency delay tracker for this BlockBackend.
+ */
+void blk_delay_tracker_destroy(BlockDelayTracker *bdt);
+
+/**
+ * Return the latency delay tracker object for the given BlockBackend.
+ *
+ * (Implemented in block-backend.c, where the BlockBackend definition resides.)
+ */
+BlockDelayTracker *blk_delay_tracker(BlockBackend *blk);
+
+/**
+ * Begin tracking an I/O request on @blk of type @op_type over @bytes starting
+ * from @offset.
+ *
+ * @request is initialized by this function.
+ *
+ * Use offset=-1 for operations that have no valid offset (e.g. flush).
+ */
+void blk_track_delay_begin(BlockBackend *blk,
+ BlockDelayTrackerRequest *request,
+ int64_t offset,
+ uint64_t bytes,
+ IoAccountingOperation op_type);
+/**
+ * Finalize I/O request tracking.
+ *
+ * @ret indicates the operation's status, with 0 for success and -errno for
+ * errors.
+ */
+void blk_track_delay_end(BlockBackend *blk,
+ BlockDelayTrackerRequest *request,
+ int ret);
+
+#endif
diff --git a/include/system/block-backend-global-state.h
b/include/system/block-backend-global-state.h
index c3849640df9..c04fcff81a7 100644
--- a/include/system/block-backend-global-state.h
+++ b/include/system/block-backend-global-state.h
@@ -102,6 +102,17 @@ void blk_update_root_state(BlockBackend *blk);
bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk);
int blk_get_open_flags_from_root_state(BlockBackend *blk);
+/**
+ * Set the nanosecond threshold for per-request latency, when to consider it
+ * sufficient of a delay to report via BLOCK_IO_DELAY QMP event.
+ */
+void blk_set_delay_report_threshold(BlockBackend *blk, uint64_t ns);
+/**
+ * Set the nanosecond threshold for per-request latency, when to consider it
+ * sufficient of a delay to stop the VM.
+ */
+void blk_set_delay_stop_threshold(BlockBackend *blk, uint64_t ns);
+
int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
int64_t pos, int size);
int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size);
diff --git a/block/block-backend-delay.c b/block/block-backend-delay.c
new file mode 100644
index 00000000000..07891573861
--- /dev/null
+++ b/block/block-backend-delay.c
@@ -0,0 +1,326 @@
+/*
+ * Keep track of ongoing BlockBackend requests, notify about excessive
+ * latency (i.e. delays), and potentially even pause the VM until such a
+ * request is done.
+ *
+ * Copyright (c) 2026 Hanna Czenczek <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "qemu/osdep.h"
+#include "block/block-backend-delay.h"
+#include "qapi/qapi-events-block.h"
+#include "system/block-backend.h"
+#include "system/qtest.h"
+#include "system/runstate.h"
+
+/**
+ * Information for BLOCK_IO_DELAY/DONE events so that:
+ * - delay_track_timer() can collect all of the events to emit in a list and
+ * emit them outside of the BlockDelayTracker lock.
+ * - blk_track_delay_end() can move the event emission to the main loop for
+ * ordering
+ */
+typedef struct DelayEvent DelayEvent;
+struct DelayEvent {
+ char *device_path;
+ IoAccountingOperation op_type;
+ uint64_t duration_ns;
+ union {
+ BlockErrorAction action; /* for BLOCK_IO_DELAY */
+ int ret; /* for BLOCK_IO_DONE */
+ };
+ bool has_offset;
+ uint64_t offset;
+ uint64_t bytes;
+ QTAILQ_ENTRY(DelayEvent) next;
+};
+
+static void delay_track_timer(void *opaque);
+static void send_done_event(void *opaque);
+
+void blk_delay_tracker_init(BlockBackend *blk)
+{
+ BlockDelayTracker *bdt = blk_delay_tracker(blk);
+
+ assert(bdt != NULL);
+
+ bdt->clock_type = qtest_enabled() ? QEMU_CLOCK_VIRTUAL
+ : QEMU_CLOCK_REALTIME;
+
+ qemu_mutex_init(&bdt->lock);
+ QTAILQ_INIT(&bdt->requests);
+
+ bdt->timer = aio_timer_new(qemu_get_aio_context(), bdt->clock_type,
+ SCALE_NS, delay_track_timer, blk);
+}
+
+void blk_delay_tracker_destroy(BlockDelayTracker *bdt)
+{
+ timer_free(bdt->timer);
+ qemu_mutex_destroy(&bdt->lock);
+ assert(QTAILQ_EMPTY(&bdt->requests));
+ g_free(bdt);
+}
+
+void blk_set_delay_report_threshold(BlockBackend *blk, uint64_t ns)
+{
+ BlockDelayTracker *bdt = blk_delay_tracker(blk);
+
+ WITH_QEMU_LOCK_GUARD(&bdt->lock) {
+ bdt->threshold_ns[BLOCK_DELAY_REPORT] = ns;
+ }
+
+ /* Wake the timer immediately to adjust to the new threshold */
+ timer_mod(bdt->timer, 0);
+}
+
+void blk_set_delay_stop_threshold(BlockBackend *blk, uint64_t ns)
+{
+ BlockDelayTracker *bdt = blk_delay_tracker(blk);
+
+ WITH_QEMU_LOCK_GUARD(&bdt->lock) {
+ bdt->threshold_ns[BLOCK_DELAY_STOP] = ns;
+ }
+
+ /* Wake the timer immediately to adjust to the new threshold */
+ timer_mod(bdt->timer, 0);
+}
+
+void blk_track_delay_begin(BlockBackend *blk,
+ BlockDelayTrackerRequest *request,
+ int64_t offset,
+ uint64_t bytes,
+ IoAccountingOperation op_type)
+{
+ BlockDelayTracker *bdt = blk_delay_tracker(blk);
+
+ *request = (BlockDelayTrackerRequest) {
+ .offset = offset,
+ .bytes = bytes,
+ .op_type = op_type,
+ };
+
+ WITH_QEMU_LOCK_GUARD(&bdt->lock) {
+ if (!bdt->threshold_ns[BLOCK_DELAY_REPORT] &&
+ !bdt->threshold_ns[BLOCK_DELAY_STOP]) {
+ /* Must be so by 0-initialization of .list */
+ assert(!QTAILQ_IN_USE(request, list));
+ return;
+ }
+
+ /* Set this under the lock so `bdt->requests` is correctly ordered */
+ request->start_time_ns = qemu_clock_get_ns(bdt->clock_type);
+ QTAILQ_INSERT_TAIL(&bdt->requests, request, list);
+ }
+
+}
+
+void blk_track_delay_end(BlockBackend *blk,
+ BlockDelayTrackerRequest *request,
+ int ret)
+{
+ BlockDelayTracker *bdt = blk_delay_tracker(blk);
+ bool need_done_event = false;
+
+ if (!QTAILQ_IN_USE(request, list)) {
+ return;
+ }
+
+ WITH_QEMU_LOCK_GUARD(&bdt->lock) {
+ for (int i = 0; i < BLOCK_DELAY__MAX; i++) {
+ need_done_event |= request->threshold_exceeded[i];
+ }
+ QTAILQ_REMOVE(&bdt->requests, request, list);
+ }
+
+ /* `device_path` is set if and only if any `threshold_exceeded` are set */
+ assert(!!request->device_path == need_done_event);
+
+ if (need_done_event) {
+ DelayEvent *event = g_new(DelayEvent, 1);
+ uint64_t now = qemu_clock_get_ns(bdt->clock_type);
+
+ *event = (DelayEvent) {
+ .device_path = request->device_path,
+ .op_type = request->op_type,
+ .duration_ns = usub64_saturate(now, request->start_time_ns),
+ .ret = ret,
+ .has_offset = request->offset >= 0,
+ .offset = request->offset,
+ .bytes = request->bytes,
+ };
+
+ /*
+ * Emit the event in the main loop, where the timer runs, too, so we
+ * always emit BLOCK_IO_DONE after all corresponding BLOCK_IO_DELAY
+ * events.
+ */
+ aio_bh_schedule_oneshot(qemu_get_aio_context(), send_done_event,
event);
+ }
+}
+
+/**
+ * Send a BLOCK_IO_DONE event from the `DelayEvent` given via `opaque`.
+ *
+ * This event, and the `device_path` in it, are freed via `g_free()`.
+ */
+static void send_done_event(void *opaque)
+{
+ DelayEvent *event = opaque;
+
+ qapi_event_send_block_io_done(event->device_path,
+ event->op_type,
+ event->duration_ns,
+ event->has_offset, event->offset,
+ event->bytes,
+ event->ret < 0);
+ g_free(event->device_path);
+ g_free(event);
+}
+
+/**
+ * Track and periodically check for stalled requests.
+ *
+ * @opaque is the `BlockBackend`.
+ *
+ * Emits events when requests take longer than the BLOCK_DELAY_REPORT
+ * threshold, and stops the VM if one takes longer than the BLOCK_DELAY_STOP
+ * threshold.
+ *
+ * Handles spurious wakes.
+ */
+static void delay_track_timer(void *opaque)
+{
+ BlockBackend *blk = opaque;
+ BlockDelayTracker *bdt = blk_delay_tracker(blk);
+ g_autofree char *dev_path = NULL;
+ bool stop_vm = false;
+ uint64_t now;
+ /* When to wake up next */
+ uint64_t timer_time = INT64_MAX;
+ /* List of events to emit */
+ QTAILQ_HEAD(, DelayEvent) delay_events =
+ QTAILQ_HEAD_INITIALIZER(delay_events);
+
+ WITH_QEMU_LOCK_GUARD(&bdt->lock) {
+ now = qemu_clock_get_ns(bdt->clock_type);
+
+ for (int i = 0; i < BLOCK_DELAY__MAX; i++) {
+ BlockDelayTrackerRequest *request;
+ uint64_t threshold_ns = bdt->threshold_ns[i];
+
+ if (!threshold_ns) {
+ continue;
+ }
+
+ /*
+ * Sleep at most for the duration of this threshold, so that we
+ * will regularly check new requests as they come in.
+ */
+ timer_time = MIN(timer_time, uadd64_saturate(now, threshold_ns));
+
+ QTAILQ_FOREACH(request, &bdt->requests, list) {
+ DelayEvent *evt;
+ char *req_dev_path;
+ uint64_t duration_ns;
+
+ /*
+ * New requests are entered at the end of the list, so it
+ * is always sorted by start_time_ns (ascending). We can
+ * stop iterating on the first request that is not yet older
+ * than the delay threshold.
+ */
+ duration_ns = usub64_saturate(now, request->start_time_ns);
+ if (duration_ns < threshold_ns) {
+ /*
+ * Ensure waking when we need to emit a delay event for
+ * this request, the one closest to the delay threshold.
+ */
+ timer_time = MIN(timer_time,
+ uadd64_saturate(request->start_time_ns,
+ threshold_ns));
+ break;
+ }
+
+ /* Only emit a delay event once */
+ if (request->threshold_exceeded[i]) {
+ continue;
+ }
+
+ /*
+ * Always use the same device path for a single request, so use
+ * the cached path if it exists already. Otherwise, use the
+ * current device path.
+ */
+ req_dev_path = request->device_path ?: dev_path;
+ if (!req_dev_path) {
+ assert(!request->device_path && !dev_path);
+
+ /*
+ * Fine to call under `BlockDelayTracker.lock` because this
+ * will not take a lock itself.
+ * The alternative would be to either call it before the
+ * lock (not yet knowing if there will be delayed
requests),
+ * or call it after, at which point `request` may no longer
+ * be alive, which would disallow putting the result into
+ * `request`. We want to put it into `request`, though, so
+ * the `BLOCK_IO_DONE` event will always emit the same path
+ * as the `BLOCK_IO_DELAY` event(s) before.
+ * So, in order to call `blk_get_attached_dev_path()` only
+ * when needed and to make `request->device_path` work as a
+ * per-request cache, we have to call it under the lock.
+ */
+ req_dev_path = dev_path = blk_get_attached_dev_path(blk);
+ }
+
+ evt = g_new(DelayEvent, 1);
+ *evt = (DelayEvent) {
+ .device_path = g_strdup(req_dev_path),
+ .op_type = request->op_type,
+ .duration_ns = duration_ns,
+ .action = i == BLOCK_DELAY_REPORT
+ ? BLOCK_ERROR_ACTION_REPORT
+ : BLOCK_ERROR_ACTION_STOP,
+ .has_offset = request->offset >= 0,
+ .offset = request->offset,
+ .bytes = request->bytes,
+ };
+ QTAILQ_INSERT_TAIL(&delay_events, evt, next);
+
+ /* For BLOCK_IO_DONE */
+ if (!request->device_path) {
+ request->device_path = g_strdup(req_dev_path);
+ }
+ request->threshold_exceeded[i] = true;
+
+ if (i == BLOCK_DELAY_STOP) {
+ stop_vm = true;
+ }
+ }
+ }
+ }
+
+ if (stop_vm) {
+ qemu_system_vmstop_request_prepare();
+ }
+ while (!QTAILQ_EMPTY(&delay_events)) {
+ DelayEvent *evt = QTAILQ_FIRST(&delay_events);
+ QTAILQ_REMOVE(&delay_events, evt, next);
+
+ qapi_event_send_block_io_delay(evt->device_path, evt->op_type,
+ evt->duration_ns, evt->action,
+ evt->has_offset, evt->offset,
+ evt->bytes);
+ g_free(evt->device_path);
+ g_free(evt);
+ }
+ if (stop_vm) {
+ qemu_system_vmstop_request(RUN_STATE_IO_HANG);
+ }
+
+ if (timer_time < INT64_MAX) {
+ timer_mod_ns(bdt->timer, timer_time);
+ }
+}
diff --git a/block/block-backend.c b/block/block-backend.c
index 78678986466..badc3986f9e 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -12,6 +12,7 @@
#include "qemu/osdep.h"
#include "system/block-backend.h"
+#include "block/block-backend-delay.h"
#include "block/block_int.h"
#include "block/blockjob.h"
#include "block/coroutines.h"
@@ -93,6 +94,8 @@ struct BlockBackend {
* Accessed with atomic ops.
*/
unsigned int in_flight;
+
+ BlockDelayTracker *delay_tracker;
};
typedef struct BlockBackendAIOCB {
@@ -377,6 +380,9 @@ BlockBackend *blk_new(AioContext *ctx, uint64_t perm,
uint64_t shared_perm)
notifier_list_init(&blk->insert_bs_notifiers);
QLIST_INIT(&blk->aio_notifiers);
+ blk->delay_tracker = g_new0(BlockDelayTracker, 1);
+ blk_delay_tracker_init(blk);
+
QTAILQ_INSERT_TAIL(&block_backends, blk, link);
return blk;
}
@@ -481,6 +487,9 @@ static void blk_delete(BlockBackend *blk)
assert(!blk->refcnt);
assert(!blk->name);
assert(!blk->dev);
+
+ blk_delay_tracker_destroy(blk->delay_tracker);
+
if (blk->public.throttle_group_member.throttle_state) {
blk_io_limits_disable(blk);
}
@@ -764,6 +773,12 @@ BlockDriverState *blk_bs(BlockBackend *blk)
return blk->root ? blk->root->bs : NULL;
}
+BlockDelayTracker *blk_delay_tracker(BlockBackend *blk)
+{
+ IO_OR_GS_CODE();
+ return blk->delay_tracker;
+}
+
static BlockBackend * GRAPH_RDLOCK bdrv_first_blk(BlockDriverState *bs)
{
BdrvChild *child;
@@ -1338,6 +1353,7 @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset,
int64_t bytes,
ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
int ret;
BlockDriverState *bs;
+ BlockDelayTrackerRequest request;
IO_CODE();
blk_wait_while_drained(blk, flags);
@@ -1353,6 +1369,8 @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset,
int64_t bytes,
}
bdrv_inc_in_flight(bs);
+ blk_track_delay_begin(blk, &request, offset, bytes,
+ IO_ACCOUNTING_OPERATION_READ);
/* throttling disk I/O */
if (qatomic_load_acquire(&tgm->throttle_state)) {
@@ -1361,6 +1379,7 @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset,
int64_t bytes,
ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
flags);
+ blk_track_delay_end(blk, &request, ret);
bdrv_dec_in_flight(bs);
return ret;
}
@@ -1413,6 +1432,7 @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset,
int64_t bytes,
ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
int ret;
BlockDriverState *bs;
+ BlockDelayTrackerRequest request;
IO_CODE();
blk_wait_while_drained(blk, flags);
@@ -1428,6 +1448,8 @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset,
int64_t bytes,
}
bdrv_inc_in_flight(bs);
+ blk_track_delay_begin(blk, &request, offset, bytes,
+ IO_ACCOUNTING_OPERATION_WRITE);
/* throttling disk I/O */
if (qatomic_load_acquire(&tgm->throttle_state)) {
throttle_group_co_io_limits_intercept(tgm, bytes, THROTTLE_WRITE);
@@ -1439,6 +1461,7 @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset,
int64_t bytes,
ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset,
flags);
+ blk_track_delay_end(blk, &request, ret);
bdrv_dec_in_flight(bs);
return ret;
}
@@ -1803,6 +1826,7 @@ static int coroutine_fn
blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes,
BdrvRequestFlags flags)
{
+ BlockDelayTrackerRequest request;
int ret;
IO_CODE();
@@ -1814,7 +1838,12 @@ blk_co_do_pdiscard(BlockBackend *blk, int64_t offset,
int64_t bytes,
return ret;
}
- return bdrv_co_pdiscard(blk->root, offset, bytes);
+ blk_track_delay_begin(blk, &request, offset, bytes,
+ IO_ACCOUNTING_OPERATION_UNMAP);
+ ret = bdrv_co_pdiscard(blk->root, offset, bytes);
+ blk_track_delay_end(blk, &request, ret);
+
+ return ret;
}
static void coroutine_fn blk_aio_pdiscard_entry(void *opaque)
@@ -1851,6 +1880,8 @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk,
int64_t offset,
/* To be called between exactly one pair of blk_inc/dec_in_flight() */
static int coroutine_fn blk_co_do_flush(BlockBackend *blk)
{
+ BlockDelayTrackerRequest request;
+ int ret;
IO_CODE();
blk_wait_while_drained(blk, 0);
GRAPH_RDLOCK_GUARD();
@@ -1859,7 +1890,12 @@ static int coroutine_fn blk_co_do_flush(BlockBackend
*blk)
return -ENOMEDIUM;
}
- return bdrv_co_flush(blk_bs(blk));
+ blk_track_delay_begin(blk, &request, -1, 0,
+ IO_ACCOUNTING_OPERATION_FLUSH);
+ ret = bdrv_co_flush(blk_bs(blk));
+ blk_track_delay_end(blk, &request, ret);
+
+ return ret;
}
static void coroutine_fn blk_aio_flush_entry(void *opaque)
@@ -2072,6 +2108,7 @@ int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk,
BlockZoneOp op,
int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset,
QEMUIOVector *qiov, BdrvRequestFlags flags)
{
+ BlockDelayTrackerRequest request;
int ret;
IO_CODE();
@@ -2083,7 +2120,10 @@ int coroutine_fn blk_co_zone_append(BlockBackend *blk,
int64_t *offset,
return -ENOMEDIUM;
}
+ blk_track_delay_begin(blk, &request, *offset, qiov->size,
+ IO_ACCOUNTING_OPERATION_ZONE_APPEND);
ret = bdrv_co_zone_append(blk_bs(blk), offset, qiov, flags);
+ blk_track_delay_end(blk, &request, ret);
blk_dec_in_flight(blk);
return ret;
}
diff --git a/block/meson.build b/block/meson.build
index bc419aebf08..f758c82f3c9 100644
--- a/block/meson.build
+++ b/block/meson.build
@@ -8,6 +8,7 @@ block_ss.add(files(
'blklogwrites.c',
'blkverify.c',
'block-backend.c',
+ 'block-backend-delay.c',
'block-copy.c',
'commit.c',
'copy-before-write.c',
--
2.55.0
