The following changes since commit 848a6caa88b9f082c89c9b41afa975761262981d:

Merge tag 'migration-20230602-pull-request' of https://gitlab.com/juan.quintela/qemu into staging (2023-06-02 17:33:29 -0700)

https://gitlab.com/hreitz/qemu.git tags/pull-block-2023-06-05

for you to fetch changes up to 42a2890a76f4783cd1c212f27856edcf2b5e8a75:

qcow2: add discard-no-unref option (2023-06-05 13:15:42 +0200)

Block patches

- Fix padding of unaligned vectored requests to match the host alignment

for vectors with 1023 or 1024 buffers

- Refactor and fix bugs in parallels's image check functionality

- Add an option to the qcow2 driver to retain (qcow2-level) allocations

on discard requests from the guest (while still forwarding the discard

to the lower level and marking the range as zero)

Hanna Czenczek (4):

util/iov: Make qiov_slice() public

block: Collapse padded I/O vecs exceeding IOV_MAX

util/iov: Remove qemu_iovec_init_extended()

iotests/iov-padding: New test

Jean-Louis Dupond (1):

qcow2: add discard-no-unref option

qapi/block-core.json | 12 ++

block/qcow2.h | 3 +

include/qemu/iov.h | 8 +-

block/io.c | 166 ++++++++++++++++++--

block/parallels.c | 190 ++++++++++++++++-------

block/qcow2-cluster.c | 32 +++-

block/qcow2.c | 18 +++

util/iov.c | 89 ++---------

qemu-options.hx | 12 ++

tests/qemu-iotests/tests/iov-padding | 85 ++++++++++

tests/qemu-iotests/tests/iov-padding.out | 59 +++++++

11 files changed, 523 insertions(+), 151 deletions(-)

create mode 100755 tests/qemu-iotests/tests/iov-padding

create mode 100644 tests/qemu-iotests/tests/iov-padding.out

2.40.1

From: Alexander Ivanov <alexander.ivanov@virtuozzo.com>

We will add more and more checks so we need a better code structure in

parallels_co_check. Let each check performs in a separate loop in a

separate helper.

Signed-off-by: Alexander Ivanov <alexander.ivanov@virtuozzo.com>

Reviewed-by: Denis V. Lunev <den@openvz.org>

Message-Id: <20230424093147.197643-8-alexander.ivanov@virtuozzo.com>

Reviewed-by: Hanna Czenczek <hreitz@redhat.com>

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>

block/parallels.c | 75 +++++++++++++++++++++++++++++++----------------

1 file changed, 49 insertions(+), 26 deletions(-)

diff --git a/block/parallels.c b/block/parallels.c

--- a/block/parallels.c

+++ b/block/parallels.c

@@ -XXX,XX +XXX,XX @@ static void parallels_check_unclean(BlockDriverState *bs,

+static int coroutine_fn GRAPH_RDLOCK

+parallels_check_outside_image(BlockDriverState *bs, BdrvCheckResult *res,

+ BdrvCheckMode fix)

+{

+ BDRVParallelsState *s = bs->opaque;

+ uint32_t i;

+ int64_t off, high_off, size;

+ size = bdrv_getlength(bs->file->bs);

+ if (size < 0) {

+ res->check_errors++;

+ return size;

+ }

+

+ high_off = 0;

+ for (i = 0; i < s->bat_size; i++) {

+ off = bat2sect(s, i) << BDRV_SECTOR_BITS;

+ if (off > size) {

+ fprintf(stderr, "%s cluster %u is outside image\n",

+ fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);

+ res->corruptions++;

+ if (fix & BDRV_FIX_ERRORS) {

+ parallels_set_bat_entry(s, i, 0);

+ res->corruptions_fixed++;

+ }

+ continue;

+ if (high_off < off) {

+ high_off = off;

+ }

+ }

+

+ if (high_off == 0) {

+ res->image_end_offset = s->data_end << BDRV_SECTOR_BITS;

+ } else {

+ res->image_end_offset = high_off + s->cluster_size;

+ s->data_end = res->image_end_offset >> BDRV_SECTOR_BITS;

+ }

+

+ return 0;

+}

+

static int coroutine_fn GRAPH_RDLOCK

parallels_co_check(BlockDriverState *bs, BdrvCheckResult *res,

BdrvCheckMode fix)

{

BDRVParallelsState *s = bs->opaque;

- int64_t size, prev_off, high_off;

- int ret = 0;

+ int64_t size, prev_off;

+ int ret;

uint32_t i;

size = bdrv_getlength(bs->file->bs);

@@ -XXX,XX +XXX,XX @@ parallels_co_check(BlockDriverState *bs, BdrvCheckResult *res,

parallels_check_unclean(bs, res, fix);

+ ret = parallels_check_outside_image(bs, res, fix);

+ if (ret < 0) {

+ goto out;

+ }

+

res->bfi.total_clusters = s->bat_size;

res->bfi.compressed_clusters = 0; /* compression is not supported */

- high_off = 0;

prev_off = 0;

for (i = 0; i < s->bat_size; i++) {

int64_t off = bat2sect(s, i) << BDRV_SECTOR_BITS;

@@ -XXX,XX +XXX,XX @@ parallels_co_check(BlockDriverState *bs, BdrvCheckResult *res,

continue;

}

- /* cluster outside the image */

- if (off > size) {

- fprintf(stderr, "%s cluster %u is outside image\n",

- fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);

- res->corruptions++;

- if (fix & BDRV_FIX_ERRORS) {

- parallels_set_bat_entry(s, i, 0);

- res->corruptions_fixed++;

- }

- prev_off = 0;

- continue;

- }

-

res->bfi.allocated_clusters++;

- if (off > high_off) {

- high_off = off;

- }

if (prev_off != 0 && (prev_off + s->cluster_size) != off) {

res->bfi.fragmented_clusters++;

@@ -XXX,XX +XXX,XX @@ parallels_co_check(BlockDriverState *bs, BdrvCheckResult *res,

prev_off = off;

}

- if (high_off == 0) {

- res->image_end_offset = s->data_end << BDRV_SECTOR_BITS;

- } else {

- res->image_end_offset = high_off + s->cluster_size;

- s->data_end = res->image_end_offset >> BDRV_SECTOR_BITS;

- }

-

if (size > res->image_end_offset) {

int64_t count;

count = DIV_ROUND_UP(size - res->image_end_offset, s->cluster_size);

2.40.1

From: Jean-Louis Dupond <jean-louis@dupond.be>

When we for example have a sparse qcow2 image and discard: unmap is enabled,

there can be a lot of fragmentation in the image after some time. Especially on VM's

that do a lot of writes/deletes.

This causes the qcow2 image to grow even over 110% of its virtual size,

because the free gaps in the image get too small to allocate new

continuous clusters. So it allocates new space at the end of the image.

Disabling discard is not an option, as discard is needed to keep the

incremental backup size as low as possible. Without discard, the

incremental backups would become large, as qemu thinks it's just dirty

blocks but it doesn't know the blocks are unneeded.

So we need to avoid fragmentation but also 'empty' the unneeded blocks in

the image to have a small incremental backup.

In addition, we also want to send the discards further down the stack, so

the underlying blocks are still discarded.

Therefor we introduce a new qcow2 option "discard-no-unref".

When setting this option to true, discards will no longer have the qcow2

driver relinquish cluster allocations. Other than that, the request is

handled as normal: All clusters in range are marked as zero, and, if

pass-discard-request is true, it is passed further down the stack.

The only difference is that the now-zero clusters are preallocated

instead of being unallocated.

This will avoid fragmentation on the qcow2 image.

Fixes: https://gitlab.com/qemu-project/qemu/-/issues/1621

Signed-off-by: Jean-Louis Dupond <jean-louis@dupond.be>

Message-Id: <20230605084523.34134-2-jean-louis@dupond.be>

Reviewed-by: Hanna Czenczek <hreitz@redhat.com>

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>

---

qapi/block-core.json | 12 ++++++++++++

block/qcow2.h | 3 +++

block/qcow2-cluster.c | 32 ++++++++++++++++++++++++++++----

block/qcow2.c | 18 ++++++++++++++++++

qemu-options.hx | 12 ++++++++++++

5 files changed, 73 insertions(+), 4 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json

--- a/qapi/block-core.json

+++ b/qapi/block-core.json

@@ -XXX,XX +XXX,XX @@

# @pass-discard-other: whether discard requests for the data source

# should be issued on other occasions where a cluster gets freed

#

+# @discard-no-unref: when enabled, discards from the guest will not cause

+# cluster allocations to be relinquished. This prevents qcow2 fragmentation

+# that would be caused by such discards. Besides potential

+# performance degradation, such fragmentation can lead to increased

+# allocation of clusters past the end of the image file,

+# resulting in image files whose file length can grow much larger

+# than their guest disk size would suggest.

+# If image file length is of concern (e.g. when storing qcow2

+# images directly on block devices), you should consider enabling

+# this option. (since 8.1)

+#

# @overlap-check: which overlap checks to perform for writes to the

# image, defaults to 'cached' (since 2.2)

#

@@ -XXX,XX +XXX,XX @@

'*pass-discard-request': 'bool',

'*pass-discard-snapshot': 'bool',

'*pass-discard-other': 'bool',

+ '*discard-no-unref': 'bool',

'*overlap-check': 'Qcow2OverlapChecks',

'*cache-size': 'int',

'*l2-cache-size': 'int',

diff --git a/block/qcow2.h b/block/qcow2.h

--- a/block/qcow2.h

+++ b/block/qcow2.h

@@ -XXX,XX +XXX,XX @@

#define QCOW2_OPT_DISCARD_REQUEST "pass-discard-request"

#define QCOW2_OPT_DISCARD_SNAPSHOT "pass-discard-snapshot"

#define QCOW2_OPT_DISCARD_OTHER "pass-discard-other"

+#define QCOW2_OPT_DISCARD_NO_UNREF "discard-no-unref"

#define QCOW2_OPT_OVERLAP "overlap-check"

#define QCOW2_OPT_OVERLAP_TEMPLATE "overlap-check.template"

#define QCOW2_OPT_OVERLAP_MAIN_HEADER "overlap-check.main-header"

@@ -XXX,XX +XXX,XX @@ typedef struct BDRVQcow2State {

bool discard_passthrough[QCOW2_DISCARD_MAX];

+ bool discard_no_unref;

+

int overlap_check; /* bitmask of Qcow2MetadataOverlap values */

bool signaled_corruption;

diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2-cluster.c

+++ b/block/qcow2-cluster.c

@@ -XXX,XX +XXX,XX @@ static int discard_in_l2_slice(BlockDriverState *bs, uint64_t offset,

uint64_t new_l2_bitmap = old_l2_bitmap;

QCow2ClusterType cluster_type =

qcow2_get_cluster_type(bs, old_l2_entry);

+ bool keep_reference = (cluster_type != QCOW2_CLUSTER_COMPRESSED) &&

+ !full_discard &&

+ (s->discard_no_unref &&

+ type == QCOW2_DISCARD_REQUEST);

/*

* If full_discard is true, the cluster should not read back as zeroes,

@@ -XXX,XX +XXX,XX @@ static int discard_in_l2_slice(BlockDriverState *bs, uint64_t offset,

new_l2_entry = new_l2_bitmap = 0;

} else if (bs->backing || qcow2_cluster_is_allocated(cluster_type)) {

if (has_subclusters(s)) {

- new_l2_entry = 0;

+ if (keep_reference) {

+ new_l2_entry = old_l2_entry;

+ } else {

+ new_l2_entry = 0;

+ }

new_l2_bitmap = QCOW_L2_BITMAP_ALL_ZEROES;

} else {

- new_l2_entry = s->qcow_version >= 3 ? QCOW_OFLAG_ZERO : 0;

+ if (s->qcow_version >= 3) {

+ if (keep_reference) {

+ new_l2_entry |= QCOW_OFLAG_ZERO;

+ } else {

+ new_l2_entry = QCOW_OFLAG_ZERO;

+ }

+ } else {

+ new_l2_entry = 0;

+ }

}

}

@@ -XXX,XX +XXX,XX @@ static int discard_in_l2_slice(BlockDriverState *bs, uint64_t offset,

if (has_subclusters(s)) {

set_l2_bitmap(s, l2_slice, l2_index + i, new_l2_bitmap);

}

- /* Then decrease the refcount */

- qcow2_free_any_cluster(bs, old_l2_entry, type);

+ if (!keep_reference) {

+ /* Then decrease the refcount */

+ qcow2_free_any_cluster(bs, old_l2_entry, type);

+ } else if (s->discard_passthrough[type] &&

+ (cluster_type == QCOW2_CLUSTER_NORMAL ||

+ cluster_type == QCOW2_CLUSTER_ZERO_ALLOC)) {

+ /* If we keep the reference, pass on the discard still */

+ bdrv_pdiscard(s->data_file, old_l2_entry & L2E_OFFSET_MASK,

+ s->cluster_size);

+ }

qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);

@@ -XXX,XX +XXX,XX @@ static const char *const mutable_opts[] = {

QCOW2_OPT_DISCARD_REQUEST,

QCOW2_OPT_DISCARD_SNAPSHOT,

QCOW2_OPT_DISCARD_OTHER,

+ QCOW2_OPT_DISCARD_NO_UNREF,

QCOW2_OPT_OVERLAP,

QCOW2_OPT_OVERLAP_TEMPLATE,

QCOW2_OPT_OVERLAP_MAIN_HEADER,

@@ -XXX,XX +XXX,XX @@ static QemuOptsList qcow2_runtime_opts = {

.type = QEMU_OPT_BOOL,

.help = "Generate discard requests when other clusters are freed",

},

+ {

+ .name = QCOW2_OPT_DISCARD_NO_UNREF,

+ .type = QEMU_OPT_BOOL,

+ .help = "Do not unreference discarded clusters",

+ },

{

.name = QCOW2_OPT_OVERLAP,

.type = QEMU_OPT_STRING,

@@ -XXX,XX +XXX,XX @@ typedef struct Qcow2ReopenState {

bool use_lazy_refcounts;

int overlap_check;

bool discard_passthrough[QCOW2_DISCARD_MAX];

+ bool discard_no_unref;

uint64_t cache_clean_interval;

QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */

} Qcow2ReopenState;

@@ -XXX,XX +XXX,XX @@ static int qcow2_update_options_prepare(BlockDriverState *bs,

r->discard_passthrough[QCOW2_DISCARD_OTHER] =

qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);

+ r->discard_no_unref = qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_NO_UNREF,

+ false);

+ if (r->discard_no_unref && s->qcow_version < 3) {

+ error_setg(errp,

+ "discard-no-unref is only supported since qcow2 version 3");

+ ret = -EINVAL;

+ goto fail;

+ }

+

switch (s->crypt_method_header) {

case QCOW_CRYPT_NONE:

if (encryptfmt) {

@@ -XXX,XX +XXX,XX @@ static void qcow2_update_options_commit(BlockDriverState *bs,

s->discard_passthrough[i] = r->discard_passthrough[i];

}

+ s->discard_no_unref = r->discard_no_unref;

+

if (s->cache_clean_interval != r->cache_clean_interval) {

cache_clean_timer_del(bs);

s->cache_clean_interval = r->cache_clean_interval;

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

issued on other occasions where a cluster gets freed

(on/off; default: off)

+ ``discard-no-unref``

+ When enabled, discards from the guest will not cause cluster

+ allocations to be relinquished. This prevents qcow2 fragmentation

+ that would be caused by such discards. Besides potential

+ performance degradation, such fragmentation can lead to increased

+ allocation of clusters past the end of the image file,

+ resulting in image files whose file length can grow much larger

+ than their guest disk size would suggest.

+ If image file length is of concern (e.g. when storing qcow2

+ images directly on block devices), you should consider enabling

+ this option.

+

``overlap-check``

Which overlap checks to perform for writes to the image

(none/constant/cached/all; default: cached). For details or

2.40.1

When processing vectored guest requests that are not aligned to the

storage request alignment, we pad them by adding head and/or tail

buffers for a read-modify-write cycle.

The guest can submit I/O vectors up to IOV_MAX (1024) in length, but

with this padding, the vector can exceed that limit. As of

4c002cef0e9abe7135d7916c51abce47f7fc1ee2 ("util/iov: make

qemu_iovec_init_extended() honest"), we refuse to pad vectors beyond the

limit, instead returning an error to the guest.

To the guest, this appears as a random I/O error. We should not return

an I/O error to the guest when it issued a perfectly valid request.

Before 4c002cef0e9abe7135d7916c51abce47f7fc1ee2, we just made the vector

longer than IOV_MAX, which generally seems to work (because the guest

assumes a smaller alignment than we really have, file-posix's

raw_co_prw() will generally see bdrv_qiov_is_aligned() return false, and

so emulate the request, so that the IOV_MAX does not matter). However,

that does not seem exactly great.

I see two ways to fix this problem:

1. We split such long requests into two requests.

2. We join some elements of the vector into new buffers to make it

shorter.

I am wary of (1), because it seems like it may have unintended side

effects.

(2) on the other hand seems relatively simple to implement, with

hopefully few side effects, so this patch does that.

To do this, the use of qemu_iovec_init_extended() in bdrv_pad_request()

is effectively replaced by the new function bdrv_create_padded_qiov(),

which not only wraps the request IOV with padding head/tail, but also

ensures that the resulting vector will not have more than IOV_MAX

elements. Putting that functionality into qemu_iovec_init_extended() is

infeasible because it requires allocating a bounce buffer; doing so

would require many more parameters (buffer alignment, how to initialize

the buffer, and out parameters like the buffer, its length, and the

original elements), which is not reasonable.

Conversely, it is not difficult to move qemu_iovec_init_extended()'s

functionality into bdrv_create_padded_qiov() by using public

qemu_iovec_* functions, so that is what this patch does.

Because bdrv_pad_request() was the only "serious" user of

qemu_iovec_init_extended(), the next patch will remove the latter

function, so the functionality is not implemented twice.

Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2141964

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>

Message-Id: <20230411173418.19549-3-hreitz@redhat.com>

block/io.c | 166 ++++++++++++++++++++++++++++++++++++++++++++++++-----

1 file changed, 151 insertions(+), 15 deletions(-)

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

* @merge_reads is true for small requests,

* if @buf_len == @head + bytes + @tail. In this case it is possible that both

* head and tail exist but @buf_len == align and @tail_buf == @buf.

+ *

+ * @write is true for write requests, false for read requests.

+ *

+ * If padding makes the vector too long (exceeding IOV_MAX), then we need to

+ * merge existing vector elements into a single one. @collapse_bounce_buf acts

+ * as the bounce buffer in such cases. @pre_collapse_qiov has the pre-collapse

+ * I/O vector elements so for read requests, the data can be copied back after

+ * the read is done.

typedef struct BdrvRequestPadding {

uint8_t *buf;

@@ -XXX,XX +XXX,XX @@ typedef struct BdrvRequestPadding {

size_t head;

size_t tail;

bool merge_reads;

+ bool write;

QEMUIOVector local_qiov;

+

+ uint8_t *collapse_bounce_buf;

+ size_t collapse_len;

+ QEMUIOVector pre_collapse_qiov;

} BdrvRequestPadding;

static bool bdrv_init_padding(BlockDriverState *bs,

int64_t offset, int64_t bytes,

+ bool write,

BdrvRequestPadding *pad)

int64_t align = bs->bl.request_alignment;

@@ -XXX,XX +XXX,XX @@ static bool bdrv_init_padding(BlockDriverState *bs,

pad->tail_buf = pad->buf + pad->buf_len - align;

@@ -XXX,XX +XXX,XX @@ zero_mem:

return 0;

}

-static void bdrv_padding_destroy(BdrvRequestPadding *pad)

+/**

+ * Free *pad's associated buffers, and perform any necessary finalization steps.

+ */

+static void bdrv_padding_finalize(BdrvRequestPadding *pad)

{

+ if (pad->collapse_bounce_buf) {

+ if (!pad->write) {

+ /*

+ * If padding required elements in the vector to be collapsed into a

+ * bounce buffer, copy the bounce buffer content back

+ */

+ qemu_iovec_from_buf(&pad->pre_collapse_qiov, 0,

+ pad->collapse_bounce_buf, pad->collapse_len);

+ }

+ qemu_vfree(pad->collapse_bounce_buf);

+ qemu_iovec_destroy(&pad->pre_collapse_qiov);

+ }

if (pad->buf) {

qemu_vfree(pad->buf);

qemu_iovec_destroy(&pad->local_qiov);

@@ -XXX,XX +XXX,XX @@ static void bdrv_padding_destroy(BdrvRequestPadding *pad)

memset(pad, 0, sizeof(*pad));

}

+/*

+ * Create pad->local_qiov by wrapping @iov in the padding head and tail, while

+ * ensuring that the resulting vector will not exceed IOV_MAX elements.

+ *

+ * To ensure this, when necessary, the first two or three elements of @iov are

+ * merged into pad->collapse_bounce_buf and replaced by a reference to that

+ * bounce buffer in pad->local_qiov.

+ *

+ * After performing a read request, the data from the bounce buffer must be

+ * copied back into pad->pre_collapse_qiov (e.g. by bdrv_padding_finalize()).

+ */

+static int bdrv_create_padded_qiov(BlockDriverState *bs,

+ BdrvRequestPadding *pad,

+ struct iovec *iov, int niov,

+ size_t iov_offset, size_t bytes)

+{

+ int padded_niov, surplus_count, collapse_count;

+

+ /* Assert this invariant */

+ assert(niov <= IOV_MAX);

+

+ /*

+ * Cannot pad if resulting length would exceed SIZE_MAX. Returning an error

+ * to the guest is not ideal, but there is little else we can do. At least

+ * this will practically never happen on 64-bit systems.

+ */

+ if (SIZE_MAX - pad->head < bytes ||

+ SIZE_MAX - pad->head - bytes < pad->tail)

+ {

+ return -EINVAL;

+ }

+

+ /* Length of the resulting IOV if we just concatenated everything */

+ padded_niov = !!pad->head + niov + !!pad->tail;

+

+ qemu_iovec_init(&pad->local_qiov, MIN(padded_niov, IOV_MAX));

+

+ if (pad->head) {

+ qemu_iovec_add(&pad->local_qiov, pad->buf, pad->head);

+ }

+

+ /*

+ * If padded_niov > IOV_MAX, we cannot just concatenate everything.

+ * Instead, merge the first two or three elements of @iov to reduce the

+ * number of vector elements as necessary.

+ */

+ if (padded_niov > IOV_MAX) {

+ /*

+ * Only head and tail can have lead to the number of entries exceeding

+ * IOV_MAX, so we can exceed it by the head and tail at most. We need

+ * to reduce the number of elements by `surplus_count`, so we merge that

+ * many elements plus one into one element.

+ */

+ surplus_count = padded_niov - IOV_MAX;

+ assert(surplus_count <= !!pad->head + !!pad->tail);

+ collapse_count = surplus_count + 1;

+

+ /*

+ * Move the elements to collapse into `pad->pre_collapse_qiov`, then

+ * advance `iov` (and associated variables) by those elements.

+ */

+ qemu_iovec_init(&pad->pre_collapse_qiov, collapse_count);

+ qemu_iovec_concat_iov(&pad->pre_collapse_qiov, iov,

+ collapse_count, iov_offset, SIZE_MAX);

+ iov += collapse_count;

+ iov_offset = 0;

+ niov -= collapse_count;

+ bytes -= pad->pre_collapse_qiov.size;

+

+ /*

+ * Construct the bounce buffer to match the length of the to-collapse

+ * vector elements, and for write requests, initialize it with the data

+ * from those elements. Then add it to `pad->local_qiov`.

+ */

+ pad->collapse_len = pad->pre_collapse_qiov.size;

+ pad->collapse_bounce_buf = qemu_blockalign(bs, pad->collapse_len);

+ if (pad->write) {

+ qemu_iovec_to_buf(&pad->pre_collapse_qiov, 0,

+ pad->collapse_bounce_buf, pad->collapse_len);

+ }

+ qemu_iovec_add(&pad->local_qiov,

+ pad->collapse_bounce_buf, pad->collapse_len);

+ }

+

+ qemu_iovec_concat_iov(&pad->local_qiov, iov, niov, iov_offset, bytes);

+

+ if (pad->tail) {

+ qemu_iovec_add(&pad->local_qiov,

+ pad->buf + pad->buf_len - pad->tail, pad->tail);

+ }

+

+ assert(pad->local_qiov.niov == MIN(padded_niov, IOV_MAX));

+ return 0;

+}

+

/*

* bdrv_pad_request

*

@@ -XXX,XX +XXX,XX @@ static void bdrv_padding_destroy(BdrvRequestPadding *pad)

* read of padding, bdrv_padding_rmw_read() should be called separately if

* needed.

*

+ * @write is true for write requests, false for read requests.

+ *

* Request parameters (@qiov, &qiov_offset, &offset, &bytes) are in-out:

* - on function start they represent original request

* - on failure or when padding is not needed they are unchanged

@@ -XXX,XX +XXX,XX @@ static void bdrv_padding_destroy(BdrvRequestPadding *pad)

static int bdrv_pad_request(BlockDriverState *bs,

QEMUIOVector **qiov, size_t *qiov_offset,

int64_t *offset, int64_t *bytes,

+ bool write,

BdrvRequestPadding *pad, bool *padded,

BdrvRequestFlags *flags)

{

+ struct iovec *sliced_iov;

+ int sliced_niov;

+ size_t sliced_head, sliced_tail;

bdrv_check_qiov_request(*offset, *bytes, *qiov, *qiov_offset, &error_abort);

- if (!bdrv_init_padding(bs, *offset, *bytes, pad)) {

+ if (!bdrv_init_padding(bs, *offset, *bytes, write, pad)) {

if (padded) {

*padded = false;

return 0;

- ret = qemu_iovec_init_extended(&pad->local_qiov, pad->buf, pad->head,

- *qiov, *qiov_offset, *bytes,

- pad->buf + pad->buf_len - pad->tail,

- pad->tail);

+ sliced_iov = qemu_iovec_slice(*qiov, *qiov_offset, *bytes,

+ &sliced_head, &sliced_tail,

+ &sliced_niov);

+

+ /* Guaranteed by bdrv_check_qiov_request() */

+ assert(*bytes <= SIZE_MAX);

+ ret = bdrv_create_padded_qiov(bs, pad, sliced_iov, sliced_niov,

+ sliced_head, *bytes);

if (ret < 0) {

- bdrv_padding_destroy(pad);

+ bdrv_padding_finalize(pad);

return ret;

*bytes += pad->head + pad->tail;

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,

flags |= BDRV_REQ_COPY_ON_READ;

}

- ret = bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad,

- NULL, &flags);

+ ret = bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, false,

+ &pad, NULL, &flags);

if (ret < 0) {

goto fail;

}

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,

bs->bl.request_alignment,

qiov, qiov_offset, flags);

tracked_request_end(&req);

- bdrv_padding_destroy(&pad);

+ bdrv_padding_finalize(&pad);

fail:

bdrv_dec_in_flight(bs);

@@ -XXX,XX +XXX,XX @@ bdrv_co_do_zero_pwritev(BdrvChild *child, int64_t offset, int64_t bytes,

/* This flag doesn't make sense for padding or zero writes */

flags &= ~BDRV_REQ_REGISTERED_BUF;

- padding = bdrv_init_padding(bs, offset, bytes, &pad);

+ padding = bdrv_init_padding(bs, offset, bytes, true, &pad);

if (padding) {

assert(!(flags & BDRV_REQ_NO_WAIT));

bdrv_make_request_serialising(req, align);

@@ -XXX,XX +XXX,XX @@ bdrv_co_do_zero_pwritev(BdrvChild *child, int64_t offset, int64_t bytes,

}

out:

- bdrv_padding_destroy(&pad);

+ bdrv_padding_finalize(&pad);

return ret;

}

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,

* bdrv_co_do_zero_pwritev() does aligning by itself, so, we do

* alignment only if there is no ZERO flag.

*/

- ret = bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad,

- &padded, &flags);

+ ret = bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, true,

+ &pad, &padded, &flags);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,

ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,

qiov, qiov_offset, flags);

- bdrv_padding_destroy(&pad);

+ bdrv_padding_finalize(&pad);

out:

tracked_request_end(&req);

2.40.1

Test that even vectored IO requests with 1024 vector elements that are

not aligned to the device's request alignment will succeed.

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>

Message-Id: <20230411173418.19549-5-hreitz@redhat.com>

tests/qemu-iotests/tests/iov-padding | 85 ++++++++++++++++++++++++

tests/qemu-iotests/tests/iov-padding.out | 59 ++++++++++++++++

2 files changed, 144 insertions(+)

create mode 100755 tests/qemu-iotests/tests/iov-padding

create mode 100644 tests/qemu-iotests/tests/iov-padding.out

diff --git a/tests/qemu-iotests/tests/iov-padding b/tests/qemu-iotests/tests/iov-padding

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/tests/iov-padding

@@ -XXX,XX +XXX,XX @@

+#!/usr/bin/env bash

+# group: rw quick

+#

+# Check the interaction of request padding (to fit alignment restrictions) with

+# vectored I/O from the guest

+#

+# Copyright Red Hat

+#

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

+}

+trap "_cleanup; exit \$status" 0 1 2 3 15

+# get standard environment, filters and checks

+cd ..

+. ./common.rc

+. ./common.filter

+_supported_fmt raw

+_supported_proto file

+_make_test_img 1M

+IMGSPEC="driver=blkdebug,align=4096,image.driver=file,image.filename=$TEST_IMG"

+# Four combinations:

+# - Offset 4096, length 1023 * 512 + 512: Fully aligned to 4k

+# - Offset 4096, length 1023 * 512 + 4096: Head is aligned, tail is not

+# - Offset 512, length 1023 * 512 + 512: Neither head nor tail are aligned

+# - Offset 512, length 1023 * 512 + 4096: Tail is aligned, head is not

+for start_offset in 4096 512; do

+ for last_element_length in 512 4096; do

+ length=$((1023 * 512 + $last_element_length))

+ echo

+ echo "== performing 1024-element vectored requests to image (offset: $start_offset; length: $length) =="

+ # Fill with data for testing

+ $QEMU_IO -c 'write -P 1 0 1M' "$TEST_IMG" | _filter_qemu_io

+

+ # 1023 512-byte buffers, and then one with length $last_element_length

+ cmd_params="-P 2 $start_offset $(yes 512 | head -n 1023 | tr '\n' ' ') $last_element_length"

+ QEMU_IO_OPTIONS="$QEMU_IO_OPTIONS_NO_FMT" $QEMU_IO \

+ -c "writev $cmd_params" \

+ --image-opts \

+ "$IMGSPEC" \

+ | _filter_qemu_io

+

+ # Read all patterns -- read the part we just wrote with writev twice,

+ # once "normally", and once with a readv, so we see that that works, too

+ QEMU_IO_OPTIONS="$QEMU_IO_OPTIONS_NO_FMT" $QEMU_IO \

+ -c "read -P 1 0 $start_offset" \

+ -c "read -P 2 $start_offset $length" \

+ -c "readv $cmd_params" \

+ -c "read -P 1 $((start_offset + length)) $((1024 * 1024 - length - start_offset))" \

+ --image-opts \

+ "$IMGSPEC" \

+ | _filter_qemu_io

+ done

+done

+

+# success, all done

+echo "*** done"

+rm -f $seq.full

+status=0

diff --git a/tests/qemu-iotests/tests/iov-padding.out b/tests/qemu-iotests/tests/iov-padding.out

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/tests/iov-padding.out

@@ -XXX,XX +XXX,XX @@

+QA output created by iov-padding

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

+

+== performing 1024-element vectored requests to image (offset: 4096; length: 524288) ==

+wrote 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 524288/524288 bytes at offset 4096

+512 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 4096/4096 bytes at offset 0

+read 524288/524288 bytes at offset 4096

+512 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 524288/524288 bytes at offset 4096

+512 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 520192/520192 bytes at offset 528384

+508 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+== performing 1024-element vectored requests to image (offset: 4096; length: 527872) ==

+wrote 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 527872/527872 bytes at offset 4096

+515.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 4096/4096 bytes at offset 0

+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 527872/527872 bytes at offset 4096

+515.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 527872/527872 bytes at offset 4096

+515.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 516608/516608 bytes at offset 531968

+504.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+== performing 1024-element vectored requests to image (offset: 512; length: 524288) ==

+wrote 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 524288/524288 bytes at offset 512

+512 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 512/512 bytes at offset 0

+512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 524288/524288 bytes at offset 512

+512 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 524288/524288 bytes at offset 512

+512 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 523776/523776 bytes at offset 524800

+511.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+== performing 1024-element vectored requests to image (offset: 512; length: 527872) ==

+wrote 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 527872/527872 bytes at offset 512

+515.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 512/512 bytes at offset 0

+512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 527872/527872 bytes at offset 512

+515.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 527872/527872 bytes at offset 512

+515.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 520192/520192 bytes at offset 528384

+508 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+*** done

2.40.1

bdrv_pad_request() was the main user of qemu_iovec_init_extended().

HEAD^ has removed that use, so we can remove qemu_iovec_init_extended()

now.

The only remaining user is qemu_iovec_init_slice(), which can easily

inline the small part it really needs.

Note that qemu_iovec_init_extended() offered a memcpy() optimization to

initialize the new I/O vector. qemu_iovec_concat_iov(), which is used

to replace its functionality, does not, but calls qemu_iovec_add() for

every single element. If we decide this optimization was important, we

will need to re-implement it in qemu_iovec_concat_iov(), which might

also benefit its pre-existing users.

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Signed-off-by: Hanna Czenczek <hreitz@redhat.com>

Message-Id: <20230411173418.19549-4-hreitz@redhat.com>

---

include/qemu/iov.h | 5 ---

util/iov.c | 79 +++++++---------------------------------------

2 files changed, 11 insertions(+), 73 deletions(-)

diff --git a/include/qemu/iov.h b/include/qemu/iov.h

--- a/include/qemu/iov.h

+++ b/include/qemu/iov.h

@@ -XXX,XX +XXX,XX @@ static inline void *qemu_iovec_buf(QEMUIOVector *qiov)

void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);

void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);

-int qemu_iovec_init_extended(

- QEMUIOVector *qiov,

- void *head_buf, size_t head_len,

- QEMUIOVector *mid_qiov, size_t mid_offset, size_t mid_len,

- void *tail_buf, size_t tail_len);

void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,

size_t offset, size_t len);

struct iovec *qemu_iovec_slice(QEMUIOVector *qiov,

diff --git a/util/iov.c b/util/iov.c

index XXXXXXX..XXXXXXX 100644

--- a/util/iov.c

+++ b/util/iov.c

@@ -XXX,XX +XXX,XX @@ int qemu_iovec_subvec_niov(QEMUIOVector *qiov, size_t offset, size_t len)

return niov;

-/*

- * Compile new iovec, combining @head_buf buffer, sub-qiov of @mid_qiov,

- * and @tail_buf buffer into new qiov.

- */

-int qemu_iovec_init_extended(

- QEMUIOVector *qiov,

- void *head_buf, size_t head_len,

- QEMUIOVector *mid_qiov, size_t mid_offset, size_t mid_len,

- void *tail_buf, size_t tail_len)

-{

- size_t mid_head, mid_tail;

- int total_niov, mid_niov = 0;

- struct iovec *p, *mid_iov = NULL;

-

- assert(mid_qiov->niov <= IOV_MAX);

-

- if (SIZE_MAX - head_len < mid_len ||