The following changes since commit 609ef9f451759151d0bfe7c3843410ab94d68f18:

Merge remote-tracking branch 'remotes/berrange/tags/qio-next-pull-request' into staging (2018-06-28 17:53:31 +0100)

are available in the git repository at:

for you to fetch changes up to 583c99d39368526dfb57a715b04a6ceea27dbe1e:

block: Remove unused sector-based vectored I/O (2018-06-29 14:20:56 +0200)

- Make truncate operations asynchronous (so that preallocation in

blockdev-create doesn't block the main loop any more)

- usb-storage: Add rerror/werror properties

- nvme: Add num_queues property

- qemu-img convert: Copy offloading fixes (including data corruption fix)

- qcow2: Fix cluster leak on temporary write error

- Use byte-based functions instead of bdrv_co_readv/writev()

- Various small fixes and cleanups

Eric Blake (8):

parallels: Switch to byte-based calls

qcow: Switch get_cluster_offset to be byte-based

qcow: Switch qcow_co_readv to byte-based calls

qcow: Switch qcow_co_writev to byte-based calls

qcow: Switch to a byte-based driver

replication: Switch to byte-based calls

vhdx: Switch to byte-based calls

block: Remove unused sector-based vectored I/O

Fam Zheng (5):

qcow2: Remove dead check on !ret

block: Move request tracking to children in copy offloading

qcow2: Fix src_offset in copy offloading

iscsi: Don't blindly use designator length in response for memcpy

file-posix: Fix EINTR handling

Kevin Wolf (12):

qapi/job: The next release will be 3.0

usb-storage: Add rerror/werror properties

qcow2: Fix qcow2_truncate() error return value

block: Convert .bdrv_truncate callback to coroutine_fn

qcow2: Remove coroutine trampoline for preallocate_co()

block: Move bdrv_truncate() implementation to io.c

block: Use tracked request for truncate

file-posix: Make .bdrv_co_truncate asynchronous

qemu-iotests: Update 026.out.nocache reference output

qcow2: Free allocated clusters on write error

qemu-iotests: Test qcow2 not leaking clusters on write error

file-posix: Implement co versions of discard/flush

Markus Armbruster (3):

block-qdict: Pacify Coverity after commit f1b34a248e9

block/crypto: Pacify Coverity after commit f853465aacb

block/crypto: Simplify block_crypto_{open,create}_opts_init()

Weiping Zhang (1):

hw/block/nvme: add optional parameter num_queues for nvme device

qapi/job.json | 18 +-

block/crypto.h | 8 +-

block/qcow2.h | 1 +

include/block/block.h | 8 +-

include/block/block_int.h | 7 +-

include/block/raw-aio.h | 4 +-

include/hw/scsi/scsi.h | 2 +

block.c | 64 +------

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

block/crypto.c | 112 +++--------

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

block/file-win32.c | 6 +-

block/gluster.c | 14 +-

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

block/iscsi.c | 10 +-

block/nfs.c | 7 +-

block/parallels.c | 16 +-

block/qcow.c | 135 +++++++-------

block/qcow2-cluster.c | 11 ++

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

block/qed.c | 8 +-

block/raw-format.c | 8 +-

block/rbd.c | 8 +-

block/replication.c | 14 +-

block/sheepdog.c | 12 +-

block/ssh.c | 6 +-

block/vhdx.c | 12 +-

hw/block/nvme.c | 5 +-

hw/scsi/scsi-bus.c | 11 +-

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

qobject/block-qdict.c | 16 +-

tests/qemu-iotests/026 | 17 ++

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

tests/qemu-iotests/026.out.nocache | 14 +-

tests/qemu-iotests/063 | 9 +

tests/qemu-iotests/063.out | 12 ++

36 files changed, 685 insertions(+), 634 deletions(-)

From: Eric Blake <eblake@redhat.com>

We are gradually moving away from sector-based interfaces, towards

byte-based. Now that all callers of vectored I/O have been converted

to use our preferred byte-based bdrv_co_p{read,write}v(), we can

delete the unused bdrv_co_{read,write}v().

Furthermore, this gets rid of the signature difference between the

public bdrv_co_writev() and the callback .bdrv_co_writev (the

latter still exists, because some drivers still need more work

before they are fully byte-based).

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

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Reviewed-by: Jeff Cody <jcody@redhat.com>

include/block/block.h | 4 ----

block/io.c | 36 ------------------------------------

2 files changed, 40 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 @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes);

int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov);

int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,

const void *buf, int count);

-int coroutine_fn bdrv_co_readv(BdrvChild *child, int64_t sector_num,

- int nb_sectors, QEMUIOVector *qiov);

-int coroutine_fn bdrv_co_writev(BdrvChild *child, int64_t sector_num,

- int nb_sectors, QEMUIOVector *qiov);

/*

* Efficiently zero a region of the disk image. Note that this is a regular

* I/O request like read or write and should have a reasonable size. This

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 @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,

return ret;

}

-static int coroutine_fn bdrv_co_do_readv(BdrvChild *child,

- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

- BdrvRequestFlags flags)

-{

- if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {

- return -EINVAL;

- }

-

- return bdrv_co_preadv(child, sector_num << BDRV_SECTOR_BITS,

- nb_sectors << BDRV_SECTOR_BITS, qiov, flags);

-}

-

-int coroutine_fn bdrv_co_readv(BdrvChild *child, int64_t sector_num,

- int nb_sectors, QEMUIOVector *qiov)

-{

- return bdrv_co_do_readv(child, sector_num, nb_sectors, qiov, 0);

-}

-

static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,

int64_t offset, int bytes, BdrvRequestFlags flags)

{

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

return ret;

}

-static int coroutine_fn bdrv_co_do_writev(BdrvChild *child,

- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

- BdrvRequestFlags flags)

-{

- if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {

- return -EINVAL;

- }

-

- return bdrv_co_pwritev(child, sector_num << BDRV_SECTOR_BITS,

- nb_sectors << BDRV_SECTOR_BITS, qiov, flags);

-}

-

-int coroutine_fn bdrv_co_writev(BdrvChild *child, int64_t sector_num,

- int nb_sectors, QEMUIOVector *qiov)

-{

- return bdrv_co_do_writev(child, sector_num, nb_sectors, qiov, 0);

-}

-

int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,

int bytes, BdrvRequestFlags flags)

{

2.13.6

bdrv_truncate() is an operation that can block (even for a quite long

time, depending on the PreallocMode) in I/O paths that shouldn't block.

Convert it to a coroutine_fn so that we have the infrastructure for

drivers to make their .bdrv_co_truncate implementation asynchronous.

@@ -XXX,XX +XXX,XX @@ struct BlockDriver {

* bdrv_parse_filename.

*/

const char *protocol_name;

- int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp);

+ int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp);

int64_t (*bdrv_getlength)(BlockDriverState *bs);

bool has_variable_length;

@@ -XXX,XX +XXX,XX @@ exit:

/**

* Truncate file to 'offset' bytes (needed only for file protocols)

*/

-int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,

- Error **errp)

+int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

BlockDriverState *bs = child->bs;

BlockDriver *drv = bs->drv;

@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,

return -EINVAL;

}

- if (!drv->bdrv_truncate) {

+ bdrv_inc_in_flight(bs);

+

+ if (!drv->bdrv_co_truncate) {

if (bs->file && drv->is_filter) {

- return bdrv_truncate(bs->file, offset, prealloc, errp);

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

+ goto out;

}

error_setg(errp, "Image format driver does not support resize");

- return -ENOTSUP;

+ ret = -ENOTSUP;

+ goto out;

}

if (bs->read_only) {

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

- return -EACCES;

+ ret = -EACCES;

+ goto out;

}

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

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

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

if (ret < 0) {

- return ret;

+ goto out;

}

ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);

if (ret < 0) {

@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,

bdrv_dirty_bitmap_truncate(bs, offset);

bdrv_parent_cb_resize(bs);

atomic_inc(&bs->write_gen);

+

+out:

+ bdrv_dec_in_flight(bs);

return ret;

}

+typedef struct TruncateCo {

+ BdrvChild *child;

+ int64_t offset;

+ PreallocMode prealloc;

+ Error **errp;

+ int ret;

+} TruncateCo;

+

+static void coroutine_fn bdrv_truncate_co_entry(void *opaque)

+{

+ TruncateCo *tco = opaque;

+ tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->prealloc,

+ tco->errp);

+}

+

+int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,

+ Error **errp)

+{

+ Coroutine *co;

+ TruncateCo tco = {

+ .child = child,

+ .offset = offset,

+ .prealloc = prealloc,

+ .errp = errp,

+ .ret = NOT_DONE,

+ };

+

+ if (qemu_in_coroutine()) {

+ /* Fast-path if already in coroutine context */

+ bdrv_truncate_co_entry(&tco);

+ } else {

+ co = qemu_coroutine_create(bdrv_truncate_co_entry, &tco);

+ qemu_coroutine_enter(co);

+ BDRV_POLL_WHILE(child->bs, tco.ret == NOT_DONE);

+ }

+

+ return tco.ret;

+}

+

/**

* Length of a allocated file in bytes. Sparse files are counted by actual

* allocated space. Return < 0 if error or unknown.

diff --git a/block/copy-on-read.c b/block/copy-on-read.c

index XXXXXXX..XXXXXXX 100644

--- a/block/copy-on-read.c

+++ b/block/copy-on-read.c

@@ -XXX,XX +XXX,XX @@ static int64_t cor_getlength(BlockDriverState *bs)

}

-static int cor_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn cor_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

- return bdrv_truncate(bs->file, offset, prealloc, errp);

+ return bdrv_co_truncate(bs->file, offset, prealloc, errp);

}

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_copy_on_read = {

.bdrv_child_perm = cor_child_perm,

.bdrv_getlength = cor_getlength,

- .bdrv_truncate = cor_truncate,

+ .bdrv_co_truncate = cor_co_truncate,

.bdrv_co_preadv = cor_co_preadv,

.bdrv_co_pwritev = cor_co_pwritev,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/crypto.c

+++ b/block/crypto.c

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

return ret;

}

-static int block_crypto_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn

+block_crypto_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

BlockCrypto *crypto = bs->opaque;

uint64_t payload_offset =

@@ -XXX,XX +XXX,XX @@ static int block_crypto_truncate(BlockDriverState *bs, int64_t offset,

offset += payload_offset;

- return bdrv_truncate(bs->file, offset, prealloc, errp);

+ return bdrv_co_truncate(bs->file, offset, prealloc, errp);

}

static void block_crypto_close(BlockDriverState *bs)

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_crypto_luks = {

.bdrv_child_perm = bdrv_format_default_perms,

.bdrv_co_create = block_crypto_co_create_luks,

.bdrv_co_create_opts = block_crypto_co_create_opts_luks,

- .bdrv_truncate = block_crypto_truncate,

+ .bdrv_co_truncate = block_crypto_co_truncate,

.create_opts = &block_crypto_create_opts_luks,

.bdrv_reopen_prepare = block_crypto_reopen_prepare,

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

index XXXXXXX..XXXXXXX 100644

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

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

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

return result;

}

-static int raw_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

BDRVRawState *s = bs->opaque;

struct stat st;

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {

.bdrv_io_unplug = raw_aio_unplug,

.bdrv_attach_aio_context = raw_aio_attach_aio_context,

- .bdrv_truncate = raw_truncate,

+ .bdrv_co_truncate = raw_co_truncate,

.bdrv_getlength = raw_getlength,

.bdrv_get_info = raw_get_info,

.bdrv_get_allocated_file_size

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_device = {

.bdrv_io_plug = raw_aio_plug,

.bdrv_io_unplug = raw_aio_unplug,

- .bdrv_truncate = raw_truncate,

+ .bdrv_co_truncate = raw_co_truncate,

.bdrv_getlength    = raw_getlength,

.bdrv_get_info = raw_get_info,

.bdrv_get_allocated_file_size

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {

.bdrv_io_plug = raw_aio_plug,

.bdrv_io_unplug = raw_aio_unplug,

- .bdrv_truncate = raw_truncate,

+ .bdrv_co_truncate = raw_co_truncate,

.bdrv_getlength = raw_getlength,

.has_variable_length = true,

.bdrv_get_allocated_file_size

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {

.bdrv_io_plug = raw_aio_plug,

.bdrv_io_unplug = raw_aio_unplug,

- .bdrv_truncate = raw_truncate,

+ .bdrv_co_truncate = raw_co_truncate,

.bdrv_getlength = raw_getlength,

.has_variable_length = true,

.bdrv_get_allocated_file_size

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

index XXXXXXX..XXXXXXX 100644

--- a/block/file-win32.c

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

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

-static int raw_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

BDRVRawState *s = bs->opaque;

LONG low, high;

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {

.bdrv_aio_pwritev = raw_aio_pwritev,

.bdrv_aio_flush = raw_aio_flush,

- .bdrv_truncate    = raw_truncate,

+ .bdrv_co_truncate = raw_co_truncate,

.bdrv_getlength    = raw_getlength,

.bdrv_get_allocated_file_size

= raw_get_allocated_file_size,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/gluster.c

+++ b/block/gluster.c

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

return acb.ret;

}

-static int qemu_gluster_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,

+ int64_t offset,

+ PreallocMode prealloc,

+ Error **errp)

{

BDRVGlusterState *s = bs->opaque;

return qemu_gluster_do_truncate(s->fd, offset, prealloc, errp);

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster = {

.bdrv_co_create_opts = qemu_gluster_co_create_opts,

.bdrv_getlength = qemu_gluster_getlength,

.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,

- .bdrv_truncate = qemu_gluster_truncate,

+ .bdrv_co_truncate = qemu_gluster_co_truncate,

.bdrv_co_readv = qemu_gluster_co_readv,

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_tcp = {

.bdrv_co_create_opts = qemu_gluster_co_create_opts,

.bdrv_getlength = qemu_gluster_getlength,

.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,

- .bdrv_truncate = qemu_gluster_truncate,

+ .bdrv_co_truncate = qemu_gluster_co_truncate,

.bdrv_co_readv = qemu_gluster_co_readv,

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_unix = {

.bdrv_co_create_opts = qemu_gluster_co_create_opts,

.bdrv_getlength = qemu_gluster_getlength,

.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,

- .bdrv_truncate = qemu_gluster_truncate,

+ .bdrv_co_truncate = qemu_gluster_co_truncate,

.bdrv_co_readv = qemu_gluster_co_readv,

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_rdma = {

.bdrv_co_create_opts = qemu_gluster_co_create_opts,

.bdrv_getlength = qemu_gluster_getlength,

.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,

- .bdrv_truncate = qemu_gluster_truncate,

+ .bdrv_co_truncate = qemu_gluster_co_truncate,

.bdrv_co_readv = qemu_gluster_co_readv,

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/iscsi.c

+++ b/block/iscsi.c

@@ -XXX,XX +XXX,XX @@ static void iscsi_reopen_commit(BDRVReopenState *reopen_state)

}

}

-static int iscsi_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

IscsiLun *iscsilun = bs->opaque;

Error *local_err = NULL;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iscsi = {

.bdrv_getlength = iscsi_getlength,

.bdrv_get_info = iscsi_get_info,

- .bdrv_truncate = iscsi_truncate,

+ .bdrv_co_truncate = iscsi_co_truncate,

.bdrv_refresh_limits = iscsi_refresh_limits,

.bdrv_co_block_status = iscsi_co_block_status,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iser = {

.bdrv_getlength = iscsi_getlength,

.bdrv_get_info = iscsi_get_info,

- .bdrv_truncate = iscsi_truncate,

+ .bdrv_co_truncate = iscsi_co_truncate,

.bdrv_refresh_limits = iscsi_refresh_limits,

.bdrv_co_block_status = iscsi_co_block_status,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/nfs.c

+++ b/block/nfs.c

@@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)

return (task.ret < 0 ? task.ret : st.st_blocks * 512);

}

-static int nfs_file_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn

+nfs_file_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

NFSClient *client = bs->opaque;

int ret;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nfs = {

.bdrv_has_zero_init = nfs_has_zero_init,

.bdrv_get_allocated_file_size = nfs_get_allocated_file_size,

- .bdrv_truncate = nfs_file_truncate,

+ .bdrv_co_truncate = nfs_file_co_truncate,

.bdrv_file_open = nfs_file_open,

.bdrv_close = nfs_file_close,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@ static void coroutine_fn preallocate_co(void *opaque)

BlockDriverState *bs = params->bs;

uint64_t offset = params->offset;

uint64_t new_length = params->new_length;

- BDRVQcow2State *s = bs->opaque;

uint64_t bytes;

uint64_t host_offset = 0;

unsigned int cur_bytes;

int ret;

QCowL2Meta *meta;

- qemu_co_mutex_lock(&s->lock);

-

assert(offset <= new_length);

bytes = new_length - offset;

@@ -XXX,XX +XXX,XX @@ static void coroutine_fn preallocate_co(void *opaque)

ret = 0;

done:

- qemu_co_mutex_unlock(&s->lock);

params->ret = ret;

}

@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)

/* And if we're supposed to preallocate metadata, do that now */

if (qcow2_opts->preallocation != PREALLOC_MODE_OFF) {

+ BDRVQcow2State *s = blk_bs(blk)->opaque;

+ qemu_co_mutex_lock(&s->lock);

ret = preallocate(blk_bs(blk), 0, qcow2_opts->size);

+ qemu_co_mutex_unlock(&s->lock);

+

if (ret < 0) {

error_setg_errno(errp, -ret, "Could not preallocate metadata");

goto out;

@@ -XXX,XX +XXX,XX @@ fail:

return ret;

}

-static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

BDRVQcow2State *s = bs->opaque;

uint64_t old_length;

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

return -EINVAL;

}

+ qemu_co_mutex_lock(&s->lock);

+

/* cannot proceed if image has snapshots */

if (s->nb_snapshots) {

error_setg(errp, "Can't resize an image which has snapshots");

- return -ENOTSUP;

+ ret = -ENOTSUP;

+ goto fail;

}

/* cannot proceed if image has bitmaps */

if (s->nb_bitmaps) {

/* TODO: resize bitmaps in the image */

error_setg(errp, "Can't resize an image which has bitmaps");

- return -ENOTSUP;

+ ret = -ENOTSUP;

+ goto fail;

}

old_length = bs->total_sectors * 512;

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

if (prealloc != PREALLOC_MODE_OFF) {

error_setg(errp,

"Preallocation can't be used for shrinking an image");

- return -EINVAL;

+ ret = -EINVAL;

+ goto fail;

}

ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size),

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

QCOW2_DISCARD_ALWAYS, true);

if (ret < 0) {

error_setg_errno(errp, -ret, "Failed to discard cropped clusters");

- return ret;

+ goto fail;

}

ret = qcow2_shrink_l1_table(bs, new_l1_size);

if (ret < 0) {

error_setg_errno(errp, -ret,

"Failed to reduce the number of L2 tables");

- return ret;

+ goto fail;

}

ret = qcow2_shrink_reftable(bs);

if (ret < 0) {

error_setg_errno(errp, -ret,

"Failed to discard unused refblocks");

- return ret;

+ goto fail;

}

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

if (old_file_size < 0) {

error_setg_errno(errp, -old_file_size,

"Failed to inquire current file length");

- return old_file_size;

+ ret = old_file_size;

+ goto fail;

}

last_cluster = qcow2_get_last_cluster(bs, old_file_size);

if (last_cluster < 0) {

error_setg_errno(errp, -last_cluster,

"Failed to find the last cluster");

- return last_cluster;

+ ret = last_cluster;

+ goto fail;

}

if ((last_cluster + 1) * s->cluster_size < old_file_size) {

Error *local_err = NULL;

- bdrv_truncate(bs->file, (last_cluster + 1) * s->cluster_size,

- PREALLOC_MODE_OFF, &local_err);

+ bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,

+ PREALLOC_MODE_OFF, &local_err);

if (local_err) {

warn_reportf_err(local_err,

"Failed to truncate the tail of the image: ");

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

ret = qcow2_grow_l1_table(bs, new_l1_size, true);

if (ret < 0) {

error_setg_errno(errp, -ret, "Failed to grow the L1 table");

- return ret;

+ goto fail;

}

}

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

ret = preallocate(bs, old_length, offset);

if (ret < 0) {

error_setg_errno(errp, -ret, "Preallocation failed");

- return ret;

+ goto fail;

}

break;

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

if (old_file_size < 0) {

error_setg_errno(errp, -old_file_size,

"Failed to inquire current file length");

- return old_file_size;

+ ret = old_file_size;

+ goto fail;

}

old_file_size = ROUND_UP(old_file_size, s->cluster_size);

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

if (allocation_start < 0) {

error_setg_errno(errp, -allocation_start,

"Failed to resize refcount structures");

- return allocation_start;

+ ret = allocation_start;

+ goto fail;

}

clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start,

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

if (clusters_allocated < 0) {

error_setg_errno(errp, -clusters_allocated,

"Failed to allocate data clusters");

- return clusters_allocated;

+ ret = clusters_allocated;

+ goto fail;

}

assert(clusters_allocated == nb_new_data_clusters);

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

/* Allocate the data area */

new_file_size = allocation_start +

nb_new_data_clusters * s->cluster_size;

- ret = bdrv_truncate(bs->file, new_file_size, prealloc, errp);

+ ret = bdrv_co_truncate(bs->file, new_file_size, prealloc, errp);

if (ret < 0) {

error_prepend(errp, "Failed to resize underlying file: ");

qcow2_free_clusters(bs, allocation_start,

nb_new_data_clusters * s->cluster_size,

QCOW2_DISCARD_OTHER);

- return ret;

+ goto fail;

}

/* Create the necessary L2 entries */

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

qcow2_free_clusters(bs, host_offset,

nb_new_data_clusters * s->cluster_size,

QCOW2_DISCARD_OTHER);

- return ret;

+ goto fail;

}

guest_offset += nb_clusters * s->cluster_size;

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

if (prealloc != PREALLOC_MODE_OFF) {

/* Flush metadata before actually changing the image size */

- ret = bdrv_flush(bs);

+ ret = qcow2_write_caches(bs);

if (ret < 0) {

error_setg_errno(errp, -ret,

"Failed to flush the preallocated area to disk");

- return ret;

+ goto fail;

}

}

@@ -XXX,XX +XXX,XX @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset,

&offset, sizeof(uint64_t));

if (ret < 0) {

error_setg_errno(errp, -ret, "Failed to update the image size");

- return ret;

+ goto fail;

}

s->l1_vm_state_index = new_l1_size;

- return 0;

+ ret = 0;

+fail:

+ qemu_co_mutex_unlock(&s->lock);

+ return ret;

}

/* XXX: put compressed sectors first, then all the cluster aligned

@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,

if (cluster_offset < 0) {

return cluster_offset;

}

- return bdrv_truncate(bs->file, cluster_offset, PREALLOC_MODE_OFF, NULL);

+ return bdrv_co_truncate(bs->file, cluster_offset, PREALLOC_MODE_OFF,

+ NULL);

}

if (offset_into_cluster(s, offset)) {

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {

.bdrv_co_pdiscard = qcow2_co_pdiscard,

.bdrv_co_copy_range_from = qcow2_co_copy_range_from,

.bdrv_co_copy_range_to = qcow2_co_copy_range_to,

- .bdrv_truncate = qcow2_truncate,

+ .bdrv_co_truncate = qcow2_co_truncate,

.bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed,

.bdrv_make_empty = qcow2_make_empty,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qed.c

+++ b/block/qed.c

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

QED_AIOCB_WRITE | QED_AIOCB_ZERO);

}

-static int bdrv_qed_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs,

+ int64_t offset,

+ PreallocMode prealloc,

+ Error **errp)

{

BDRVQEDState *s = bs->opaque;

uint64_t old_image_size;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qed = {

.bdrv_co_readv = bdrv_qed_co_readv,

.bdrv_co_writev = bdrv_qed_co_writev,

.bdrv_co_pwrite_zeroes = bdrv_qed_co_pwrite_zeroes,

- .bdrv_truncate = bdrv_qed_truncate,

+ .bdrv_co_truncate = bdrv_qed_co_truncate,

.bdrv_getlength = bdrv_qed_getlength,

.bdrv_get_info = bdrv_qed_get_info,

.bdrv_refresh_limits = bdrv_qed_refresh_limits,

diff --git a/block/raw-format.c b/block/raw-format.c

index XXXXXXX..XXXXXXX 100644

--- a/block/raw-format.c

+++ b/block/raw-format.c

@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)

}

}

-static int raw_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

BDRVRawState *s = bs->opaque;

@@ -XXX,XX +XXX,XX @@ static int raw_truncate(BlockDriverState *bs, int64_t offset,

s->size = offset;

offset += s->offset;

- return bdrv_truncate(bs->file, offset, prealloc, errp);

+ return bdrv_co_truncate(bs->file, offset, prealloc, errp);

}

static void raw_eject(BlockDriverState *bs, bool eject_flag)

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {

.bdrv_co_block_status = &raw_co_block_status,

.bdrv_co_copy_range_from = &raw_co_copy_range_from,

.bdrv_co_copy_range_to = &raw_co_copy_range_to,

- .bdrv_truncate = &raw_truncate,

+ .bdrv_co_truncate = &raw_co_truncate,

.bdrv_getlength = &raw_getlength,

.has_variable_length = true,

.bdrv_measure = &raw_measure,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/rbd.c

+++ b/block/rbd.c

@@ -XXX,XX +XXX,XX @@ static int64_t qemu_rbd_getlength(BlockDriverState *bs)

return info.size;

}

-static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,

+ int64_t offset,

+ PreallocMode prealloc,

+ Error **errp)

{

BDRVRBDState *s = bs->opaque;

int r;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {

.bdrv_get_info = qemu_rbd_getinfo,

.create_opts = &qemu_rbd_create_opts,

.bdrv_getlength = qemu_rbd_getlength,

- .bdrv_truncate = qemu_rbd_truncate,

+ .bdrv_co_truncate = qemu_rbd_co_truncate,

.protocol_name = "rbd",

.bdrv_aio_preadv = qemu_rbd_aio_preadv,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/sheepdog.c

+++ b/block/sheepdog.c

@@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs)

return s->inode.vdi_size;

}

-static int sd_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

BDRVSheepdogState *s = bs->opaque;

int ret, fd;

@@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,

assert(!flags);

if (offset > s->inode.vdi_size) {

- ret = sd_truncate(bs, offset, PREALLOC_MODE_OFF, NULL);

+ ret = sd_co_truncate(bs, offset, PREALLOC_MODE_OFF, NULL);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog = {

.bdrv_has_zero_init = bdrv_has_zero_init_1,

.bdrv_getlength = sd_getlength,

.bdrv_get_allocated_file_size = sd_get_allocated_file_size,

- .bdrv_truncate = sd_truncate,

+ .bdrv_co_truncate = sd_co_truncate,

.bdrv_co_readv = sd_co_readv,

.bdrv_co_writev = sd_co_writev,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog_tcp = {

.bdrv_has_zero_init = bdrv_has_zero_init_1,

.bdrv_getlength = sd_getlength,

.bdrv_get_allocated_file_size = sd_get_allocated_file_size,

- .bdrv_truncate = sd_truncate,

+ .bdrv_co_truncate = sd_co_truncate,

.bdrv_co_readv = sd_co_readv,

.bdrv_co_writev = sd_co_writev,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog_unix = {

.bdrv_has_zero_init = bdrv_has_zero_init_1,

.bdrv_getlength = sd_getlength,

.bdrv_get_allocated_file_size = sd_get_allocated_file_size,

- .bdrv_truncate = sd_truncate,

+ .bdrv_co_truncate = sd_co_truncate,

.bdrv_co_readv = sd_co_readv,

.bdrv_co_writev = sd_co_writev,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/ssh.c

+++ b/block/ssh.c

@@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs)

return length;

}

-static int ssh_truncate(BlockDriverState *bs, int64_t offset,

- PreallocMode prealloc, Error **errp)

+static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,

+ PreallocMode prealloc, Error **errp)

{

BDRVSSHState *s = bs->opaque;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_ssh = {

.bdrv_co_readv = ssh_co_readv,

.bdrv_co_writev = ssh_co_writev,

.bdrv_getlength = ssh_getlength,

- .bdrv_truncate = ssh_truncate,

+ .bdrv_co_truncate = ssh_co_truncate,

.bdrv_co_flush_to_disk = ssh_co_flush,

.create_opts = &ssh_create_opts,

};

2.13.6

From: Eric Blake <eblake@redhat.com>

We are gradually moving away from sector-based interfaces, towards

byte-based. Make the change for the last few sector-based calls

into the block layer from the replication driver.

Ideally, the replication driver should switch to doing everything

byte-based, but that's a more invasive change that requires a

bit more auditing.

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

Reviewed-by: Jeff Cody <jcody@redhat.com>

block/replication.c | 14 ++++++++------

1 file changed, 8 insertions(+), 6 deletions(-)

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

--- a/block/replication.c

+++ b/block/replication.c

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

backup_cow_request_begin(&req, child->bs->job,

sector_num * BDRV_SECTOR_SIZE,

remaining_bytes);

- ret = bdrv_co_readv(bs->file, sector_num, remaining_sectors,

- qiov);

+ ret = bdrv_co_preadv(bs->file, sector_num * BDRV_SECTOR_SIZE,

+ remaining_bytes, qiov, 0);

backup_cow_request_end(&req);

- ret = bdrv_co_readv(bs->file, sector_num, remaining_sectors, qiov);

+ ret = bdrv_co_preadv(bs->file, sector_num * BDRV_SECTOR_SIZE,

+ remaining_sectors * BDRV_SECTOR_SIZE, qiov, 0);

out:

return replication_return_value(s, ret);

}

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

if (ret == 0) {

- ret = bdrv_co_writev(top, sector_num,

- remaining_sectors, qiov);

+ ret = bdrv_co_pwritev(top, sector_num * BDRV_SECTOR_SIZE,

+ remaining_sectors * BDRV_SECTOR_SIZE, qiov, 0);

return replication_return_value(s, ret);

}

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

qemu_iovec_concat(&hd_qiov, qiov, bytes_done, count);

target = ret ? top : base;

- ret = bdrv_co_writev(target, sector_num, n, &hd_qiov);

+ ret = bdrv_co_pwritev(target, sector_num * BDRV_SECTOR_SIZE,

+ n * BDRV_SECTOR_SIZE, &hd_qiov, 0);

if (ret < 0) {

goto out1;

}

2.13.6

From: Eric Blake <eblake@redhat.com>

We are gradually moving away from sector-based interfaces, towards

byte-based. Make the change for the last few sector-based calls

into the block layer from the vhdx driver.

Ideally, the vhdx driver should switch to doing everything

byte-based, but that's a more invasive change that requires a

bit more auditing.

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

Reviewed-by: Jeff Cody <jcody@redhat.com>

block/vhdx.c | 12 ++++++------

1 file changed, 6 insertions(+), 6 deletions(-)

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

--- a/block/vhdx.c

+++ b/block/vhdx.c

@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_readv(BlockDriverState *bs, int64_t sector_num,

break;

case PAYLOAD_BLOCK_FULLY_PRESENT:

qemu_co_mutex_unlock(&s->lock);

- ret = bdrv_co_readv(bs->file,

- sinfo.file_offset >> BDRV_SECTOR_BITS,

- sinfo.sectors_avail, &hd_qiov);