The following changes since commit b34181056c04e05db6c632063012beaee7006a37:

Merge remote-tracking branch 'remotes/rth/tags/pull-sh4-20180709' into staging (2018-07-09 22:44:22 +0100)

are available in the git repository at:

for you to fetch changes up to cd47d792d7a27a57f4b621e2ff1ed8f4e83de1e9:

block: Use common write req handling in truncate (2018-07-10 16:46:22 +0200)

- Copy offloading fixes for when the copy increases the image size

- Temporary revert of the removal of deprecated -drive options

- Fix request serialisation in the image fleecing scenario

- Fix copy-on-read crash with unaligned image size

- Fix another drain crash

Ari Sundholm (2):

qapi/block-core.json: Add missing documentation for blklogwrites log-append option

block/blklogwrites: Make sure the log sector size is not too small

Cornelia Huck (4):

Revert "block: Remove dead deprecation warning code"

Revert "block: Remove deprecated -drive option serial"

Revert "block: Remove deprecated -drive option addr"

Revert "block: Remove deprecated -drive geometry options"

Fam Zheng (11):

iotests: 222: Don't run with luks

block: Prefix file driver trace points with "file_"

block: Add copy offloading trace points

block: Use BdrvChild to discard

block: Use uint64_t for BdrvTrackedRequest byte fields

block: Extract common write req handling

block: Fix handling of image enlarging write

block: Use common req handling for discard

block: Use common req handling in copy offloading

block: Fix bdrv_co_truncate overlap check

block: Use common write req handling in truncate

block: Poll after drain on attaching a node

test-bdrv-drain: Test bdrv_append() to drained node

block: Fix copy-on-read crash with partial final cluster

Vladimir Sementsov-Ogievskiy (4):

block/io: fix copy_range

block: split flags in copy_range

block: add BDRV_REQ_SERIALISING flag

block/backup: fix fleecing scheme: use serialized writes

qapi/block-core.json | 2 +

include/block/block.h | 41 +++++-

include/block/block_int.h | 21 ++-

include/hw/block/block.h | 1 +

include/sysemu/block-backend.h | 3 +-

include/sysemu/blockdev.h | 3 +

block.c | 2 +-

block/backup.c | 20 ++-

block/blkdebug.c | 2 +-

block/blklogwrites.c | 7 +-

block/blkreplay.c | 2 +-

block/block-backend.c | 8 +-

block/copy-on-read.c | 2 +-

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

block/file-win32.c | 2 +-

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

block/iscsi.c | 12 +-

block/mirror.c | 2 +-

block/qcow2-refcount.c | 2 +-

block/qcow2.c | 20 +--

block/raw-format.c | 26 ++--

block/throttle.c | 2 +-

blockdev.c | 110 ++++++++++++++

device-hotplug.c | 4 +

hw/block/block.c | 27 ++++

hw/block/nvme.c | 1 +

hw/block/virtio-blk.c | 1 +

hw/ide/qdev.c | 1 +

hw/scsi/scsi-disk.c | 1 +

hw/usb/dev-storage.c | 1 +

qemu-img.c | 2 +-

tests/ahci-test.c | 6 +-

tests/hd-geo-test.c | 37 ++++-

tests/ide-test.c | 8 +-

tests/test-bdrv-drain.c | 43 ++++++

block/trace-events | 10 +-

hmp-commands.hx | 1 +

qemu-doc.texi | 15 ++

qemu-options.hx | 14 +-

tests/qemu-iotests/197 | 9 ++

tests/qemu-iotests/197.out | 8 ++

tests/qemu-iotests/222 | 2 +

42 files changed, 647 insertions(+), 177 deletions(-)

From: Fam Zheng <famz@redhat.com>

Truncation is the last to convert from open coded req handling to

reusing helpers. This time the permission check in prepare has to adapt

to the new caller: it checks a different permission bit, and doesn't

trigger the before write notifier.

Also, truncation should always trigger a bs->total_sectors update and in

turn call parent resize_cb. Update the condition in finish helper, too.

It's intended to do a duplicated bs->read_only check before calling

bdrv_co_write_req_prepare() so that we can be more informative with the

error message, as bdrv_co_write_req_prepare() doesn't have Error

parameter.

Signed-off-by: Fam Zheng <famz@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

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

1 file changed, 35 insertions(+), 20 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/block/io.c

+++ b/block/io.c

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

is_request_serialising_and_aligned(req));

assert(req->overlap_offset <= offset);

assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);

+ assert(end_sector <= bs->total_sectors || child->perm & BLK_PERM_RESIZE);

- if (flags & BDRV_REQ_WRITE_UNCHANGED) {

- assert(child->perm & (BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE));

- } else {

- assert(child->perm & BLK_PERM_WRITE);

+ switch (req->type) {

+ case BDRV_TRACKED_WRITE:

+ case BDRV_TRACKED_DISCARD:

+ if (flags & BDRV_REQ_WRITE_UNCHANGED) {

+ assert(child->perm & (BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE));

+ } else {

+ assert(child->perm & BLK_PERM_WRITE);

+ }

+ return notifier_with_return_list_notify(&bs->before_write_notifiers,

+ req);

+ case BDRV_TRACKED_TRUNCATE:

+ assert(child->perm & BLK_PERM_RESIZE);

+ return 0;

+ default:

+ abort();

}

- assert(end_sector <= bs->total_sectors || child->perm & BLK_PERM_RESIZE);

- return notifier_with_return_list_notify(&bs->before_write_notifiers, req);

}

static inline void coroutine_fn

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

* beyond EOF cannot expand the image anyway.

*/

if (ret == 0 &&

- end_sector > bs->total_sectors &&

- req->type != BDRV_TRACKED_DISCARD) {

+ (req->type == BDRV_TRACKED_TRUNCATE ||

+ end_sector > bs->total_sectors) &&

+ req->type != BDRV_TRACKED_DISCARD) {

bs->total_sectors = end_sector;

bdrv_parent_cb_resize(bs);

bdrv_dirty_bitmap_truncate(bs, end_sector << BDRV_SECTOR_BITS);

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset,

int64_t old_size, new_bytes;

int ret;

- assert(child->perm & BLK_PERM_RESIZE);

/* if bs->drv == NULL, bs is closed, so there's nothing to do here */

if (!drv) {

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset,

* concurrently or they might be overwritten by preallocation. */

if (new_bytes) {

mark_request_serialising(&req, 1);

- wait_serialising_requests(&req);

+ }

+ if (bs->read_only) {

+ error_setg(errp, "Image is read-only");

+ ret = -EACCES;

+ goto out;

+ }

+ ret = bdrv_co_write_req_prepare(child, offset - new_bytes, new_bytes, &req,

+ 0);

+ if (ret < 0) {

+ error_setg_errno(errp, -ret,

+ "Failed to prepare request for truncation");

+ goto out;

}

if (!drv->bdrv_co_truncate) {

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset,

ret = -ENOTSUP;

goto out;

}

- if (bs->read_only) {

- error_setg(errp, "Image is read-only");

- ret = -EACCES;

- goto out;

- }

-

- assert(!(bs->open_flags & BDRV_O_INACTIVE));

ret = drv->bdrv_co_truncate(bs, offset, prealloc, errp);

if (ret < 0) {

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset,

} else {

offset = bs->total_sectors * BDRV_SECTOR_SIZE;

}

- bdrv_dirty_bitmap_truncate(bs, offset);

- bdrv_parent_cb_resize(bs);

- atomic_inc(&bs->write_gen);

+ /* It's possible that truncation succeeded but refresh_total_sectors

+ * failed, but the latter doesn't affect how we should finish the request.

+ * Pass 0 as the last parameter so that dirty bitmaps etc. are handled. */

+ bdrv_co_write_req_finish(child, offset - new_bytes, new_bytes, &req, 0);

out:

tracked_request_end(&req);

2.13.6

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Here two things are fixed:

1. Architecture

On each recursion step, we go to the child of src or dst, only for one

of them. So, it's wrong to create tracked requests for both on each

step. It leads to tracked requests duplication.

2. Wait for serializing requests on write path independently of

BDRV_REQ_NO_SERIALISING

Before commit 9ded4a01149 "backup: Use copy offloading",

BDRV_REQ_NO_SERIALISING was used for only one case: read in

copy-on-write operation during backup. Also, the flag was handled only

on read path (in bdrv_co_preadv and bdrv_aligned_preadv).

After 9ded4a01149, flag is used for not waiting serializing operations

on backup target (in same case of copy-on-write operation). This

behavior change is unsubstantiated and potentially dangerous, let's

drop it and add additional asserts and documentation.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Reviewed-by: Fam Zheng <famz@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

include/block/block.h | 12 ++++++++++++

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

2 files changed, 39 insertions(+), 15 deletions(-)

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

--- a/include/block/block.h

+++ b/include/block/block.h

@@ -XXX,XX +XXX,XX @@ typedef enum {

* opened with BDRV_O_UNMAP.

*/

BDRV_REQ_MAY_UNMAP = 0x4,

+

+ /*

+ * The BDRV_REQ_NO_SERIALISING flag is only valid for reads and means that

+ * we don't want wait_serialising_requests() during the read operation.

+ *

+ * This flag is used for backup copy-on-write operations, when we need to

+ * read old data before write (write notifier triggered). It is okay since

+ * we already waited for other serializing requests in the initiating write

+ * (see bdrv_aligned_pwritev), and it is necessary if the initiating write

+ * is already serializing (without the flag, the read would deadlock

+ * waiting for the serialising write to complete).

+ */

BDRV_REQ_NO_SERIALISING = 0x8,

BDRV_REQ_FUA = 0x10,

BDRV_REQ_WRITE_COMPRESSED = 0x20,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/io.c

+++ b/block/io.c

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

max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),

align);

+ /* BDRV_REQ_NO_SERIALISING is only for read operation */

+ assert(!(flags & BDRV_REQ_NO_SERIALISING));

waited = wait_serialising_requests(req);

assert(!waited || !req->serialising);

assert(req->overlap_offset <= offset);

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src,

BdrvRequestFlags flags,

bool recurse_src)

{

- BdrvTrackedRequest src_req, dst_req;

+ BdrvTrackedRequest req;

int ret;

if (!dst || !dst->bs) {

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src,

|| src->bs->encrypted || dst->bs->encrypted) {

return -ENOTSUP;

}

- bdrv_inc_in_flight(src->bs);

- bdrv_inc_in_flight(dst->bs);

- tracked_request_begin(&src_req, src->bs, src_offset,

- bytes, BDRV_TRACKED_READ);

- tracked_request_begin(&dst_req, dst->bs, dst_offset,

- bytes, BDRV_TRACKED_WRITE);

- if (!(flags & BDRV_REQ_NO_SERIALISING)) {

- wait_serialising_requests(&src_req);

- wait_serialising_requests(&dst_req);

- }

if (recurse_src) {

+ bdrv_inc_in_flight(src->bs);

+ tracked_request_begin(&req, src->bs, src_offset, bytes,

+ BDRV_TRACKED_READ);

+

+ if (!(flags & BDRV_REQ_NO_SERIALISING)) {

+ wait_serialising_requests(&req);

+ }

+

ret = src->bs->drv->bdrv_co_copy_range_from(src->bs,

src, src_offset,

dst, dst_offset,

bytes, flags);

+

+ tracked_request_end(&req);

+ bdrv_dec_in_flight(src->bs);

} else {

+ bdrv_inc_in_flight(dst->bs);

+ tracked_request_begin(&req, dst->bs, dst_offset, bytes,

+ BDRV_TRACKED_WRITE);

+

+ /* BDRV_REQ_NO_SERIALISING is only for read operation,

+ * so we ignore it in flags.

+ */

+ wait_serialising_requests(&req);

+

ret = dst->bs->drv->bdrv_co_copy_range_to(dst->bs,

src, src_offset,

dst, dst_offset,

bytes, flags);

+

+ tracked_request_end(&req);

+ bdrv_dec_in_flight(dst->bs);

}

- tracked_request_end(&src_req);

- tracked_request_end(&dst_req);

- bdrv_dec_in_flight(src->bs);

- bdrv_dec_in_flight(dst->bs);

+

return ret;

}

2.13.6

From: Fam Zheng <famz@redhat.com>

Two problems exist when a write request that enlarges the image (i.e.

write beyond EOF) finishes:

1) parent is not notified about size change;

2) dirty bitmap is not resized although we try to set the dirty bits;

Fix them just like how bdrv_co_truncate works.

Signed-off-by: Fam Zheng <famz@redhat.com>

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

1 file changed, 7 insertions(+), 3 deletions(-)

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

--- a/block/io.c

+++ b/block/io.c

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

static AioWait drain_all_aio_wait;

+static void bdrv_parent_cb_resize(BlockDriverState *bs);

static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,

int64_t offset, int bytes, BdrvRequestFlags flags);

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

BlockDriverState *bs = child->bs;

atomic_inc(&bs->write_gen);

- bdrv_set_dirty(bs, offset, bytes);

stat64_max(&bs->wr_highest_offset, offset + bytes);

- if (ret == 0) {

- bs->total_sectors = MAX(bs->total_sectors, end_sector);

+ if (ret == 0 &&

+ end_sector > bs->total_sectors) {

+ bs->total_sectors = end_sector;

+ bdrv_parent_cb_resize(bs);

+ bdrv_dirty_bitmap_truncate(bs, end_sector << BDRV_SECTOR_BITS);

}

+ bdrv_set_dirty(bs, offset, bytes);

}

/*

2.13.6

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Pass read flags and write flags separately. This is needed to handle

coming BDRV_REQ_NO_SERIALISING clearly in following patches.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Reviewed-by: Fam Zheng <famz@redhat.com>

include/block/block.h | 3 ++-

include/block/block_int.h | 14 +++++++++----

include/sysemu/block-backend.h | 3 ++-

block/backup.c | 2 +-

block/block-backend.c | 5 +++--

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

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

block/iscsi.c | 9 ++++++---

block/qcow2.c | 20 +++++++++---------

block/raw-format.c | 24 ++++++++++++++--------

qemu-img.c | 2 +-

11 files changed, 90 insertions(+), 59 deletions(-)

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector

ret = blk_co_copy_range(blk, offset, s->target,

sector_num << BDRV_SECTOR_BITS,

- n << BDRV_SECTOR_BITS, 0);

+ n << BDRV_SECTOR_BITS, 0, 0);

if (ret < 0) {

return ret;

2.13.6

From: Fam Zheng <famz@redhat.com>

If we are growing the image and potentially using preallocation for the

new area, we need to make sure that no write requests are made to the

"preallocated" area which is [@old_size, @offset), not

[@offset, offset * 2 - @old_size).

Signed-off-by: Fam Zheng <famz@redhat.com>

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

block/io.c | 3 ++-

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

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

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset,

}

bdrv_inc_in_flight(bs);

- tracked_request_begin(&req, bs, offset, new_bytes, BDRV_TRACKED_TRUNCATE);

+ tracked_request_begin(&req, bs, offset - new_bytes, new_bytes,

+ BDRV_TRACKED_TRUNCATE);

/* If we are growing the image and potentially using preallocation for the

* new area, we need to make sure that no write requests are made to it

2.13.6

From: Fam Zheng <famz@redhat.com>

Reuse the new bdrv_co_write_req_prepare/finish helpers. The variation

here is that discard requests don't affect bs->wr_highest_offset, and it

cannot extend the image.

Signed-off-by: Fam Zheng <famz@redhat.com>

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

1 file changed, 23 insertions(+), 10 deletions(-)

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

--- a/block/io.c

+++ b/block/io.c

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

atomic_inc(&bs->write_gen);

- stat64_max(&bs->wr_highest_offset, offset + bytes);

-

+ /*

+ * Discard cannot extend the image, but in error handling cases, such as

+ * when reverting a qcow2 cluster allocation, the discarded range can pass

+ * the end of image file, so we cannot assert about BDRV_TRACKED_DISCARD

+ * here. Instead, just skip it, since semantically a discard request

+ * beyond EOF cannot expand the image anyway.

+ */

if (ret == 0 &&

- end_sector > bs->total_sectors) {

+ end_sector > bs->total_sectors &&

+ req->type != BDRV_TRACKED_DISCARD) {

bs->total_sectors = end_sector;

bdrv_parent_cb_resize(bs);

bdrv_dirty_bitmap_truncate(bs, end_sector << BDRV_SECTOR_BITS);

- bdrv_set_dirty(bs, offset, bytes);

+ if (req->bytes) {

+ switch (req->type) {

+ case BDRV_TRACKED_WRITE:

+ stat64_max(&bs->wr_highest_offset, offset + bytes);

+ /* fall through, to set dirty bits */

+ case BDRV_TRACKED_DISCARD:

+ bdrv_set_dirty(bs, offset, bytes);

+ break;

+ default:

+ break;

+ }

+ }

/*

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int bytes)

ret = bdrv_check_byte_request(bs, offset, bytes);

if (ret < 0) {

return ret;

- } else if (bs->read_only) {

- return -EPERM;

}

- assert(!(bs->open_flags & BDRV_O_INACTIVE));

/* Do nothing if disabled. */

if (!(bs->open_flags & BDRV_O_UNMAP)) {

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int bytes)

bdrv_inc_in_flight(bs);

tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_DISCARD);

- ret = notifier_with_return_list_notify(&bs->before_write_notifiers, &req);

+ ret = bdrv_co_write_req_prepare(child, offset, bytes, &req, 0);

if (ret < 0) {

goto out;

}

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int bytes)

}

ret = 0;

out:

- atomic_inc(&bs->write_gen);

- bdrv_set_dirty(bs, req.offset, req.bytes);

+ bdrv_co_write_req_finish(child, req.offset, req.bytes, &req, ret);

tracked_request_end(&req);

bdrv_dec_in_flight(bs);

return ret;

2.13.6

Commit dcf94a23b1 ('block: Don't poll in parent drain callbacks')

removed polling in bdrv_child_cb_drained_begin() on the grounds that the

original bdrv_drain() already will poll and BdrvChildRole.drained_begin

calls must not cause graph changes (and therefore must not call

aio_poll() or the recursion through the graph will break.

This reasoning is correct for calls through bdrv_do_drained_begin().

However, BdrvChildRole.drained_begin is also called when a node that is

already in a drained section (i.e. bdrv_do_drained_begin() has already

returned and therefore can't poll any more) is attached to a new parent.

In this case, we must explicitly poll to have all requests completed

before the drained new child can be attached to the parent.

In bdrv_replace_child_noperm(), we know that we're not inside the

recursion of bdrv_do_drained_begin() because graph changes are not

allowed there, and bdrv_replace_child_noperm() is a graph change. The

call of BdrvChildRole.drained_begin() must therefore be followed by a

BDRV_POLL_WHILE() that waits for the completion of requests.

include/block/block.h | 8 ++++++++

include/block/block_int.h | 3 +++

block.c | 2 +-

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

4 files changed, 32 insertions(+), 7 deletions(-)

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,

}

assert(num >= 0);

for (i = 0; i < num; i++) {

- child->role->drained_begin(child);

+ bdrv_parent_drained_begin_single(child, true);

}

}

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

index XXXXXXX..XXXXXXX 100644

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,

if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {

continue;

}

- if (c->role->drained_begin) {

- c->role->drained_begin(c);

- }

+ bdrv_parent_drained_begin_single(c, false);

}

@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

}

}

+static bool bdrv_parent_drained_poll_single(BdrvChild *c)

+{

+ if (c->role->drained_poll) {

+ return c->role->drained_poll(c);

+ }

+ return false;

+}

+

static bool bdrv_parent_drained_poll(BlockDriverState *bs, BdrvChild *ignore,

bool ignore_bds_parents)

{

@@ -XXX,XX +XXX,XX @@ static bool bdrv_parent_drained_poll(BlockDriverState *bs, BdrvChild *ignore,

if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {

continue;

}

- if (c->role->drained_poll) {

- busy |= c->role->drained_poll(c);

- }

+ busy |= bdrv_parent_drained_poll_single(c);

}

return busy;

}

+void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)

+{

+ if (c->role->drained_begin) {

+ c->role->drained_begin(c);

+ }

+ if (poll) {

+ BDRV_POLL_WHILE(c->bs, bdrv_parent_drained_poll_single(c));

+ }

+}

+

static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src)

{

dst->opt_transfer = MAX(dst->opt_transfer, src->opt_transfer);

2.13.6