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)

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

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

--- 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

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

--- 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)) {

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"

+# 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

We must check that zone information is present before running

update_zones_wp().

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>

block/file-posix.c | 3 ++-

1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/block/file-posix.c b/block/file-posix.c

--- a/block/file-posix.c

+++ b/block/file-posix.c

@@ -XXX,XX +XXX,XX @@ out:

}

}

} else {

- if (type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {

+ if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&

+ bs->bl.zoned != BLK_Z_NONE) {

update_zones_wp(bs, s->fd, 0, 1);

}

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

--- 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

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>