The following changes since commit 527266f324def9f7f392fe3b0dd940cb8dc699d9:

Merge remote-tracking branch 'remotes/armbru/tags/pull-pflash-2019-03-26' into staging (2019-03-26 09:57:07 +0000)

are available in the Git repository at:

for you to fetch changes up to c6e3f520c802c5cb2de80576aba7f9f1fe985d8b:

qemu-io: Add write -n for BDRV_REQ_NO_FALLBACK (2019-03-26 11:37:51 +0100)

- Fix slow pre-zeroing in qemu-img convert

- Test case for block job pausing on I/O errors

Kevin Wolf (6):

block: Remove error messages in bdrv_make_zero()

block: Add BDRV_REQ_NO_FALLBACK

block: Advertise BDRV_REQ_NO_FALLBACK in filter drivers

file-posix: Support BDRV_REQ_NO_FALLBACK for zero writes

qemu-img: Use BDRV_REQ_NO_FALLBACK for pre-zeroing

qemu-io: Add write -n for BDRV_REQ_NO_FALLBACK

Vladimir Sementsov-Ogievskiy (1):

iotests: add 248: test resume mirror after auto pause on ENOSPC

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

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

block/blkdebug.c | 2 +-

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

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

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

block/mirror.c | 3 +-

block/raw-format.c | 2 +-

qemu-img.c | 2 +-

qemu-io-cmds.c | 13 +++++++--

tests/qemu-iotests/248 | 71 ++++++++++++++++++++++++++++++++++++++++++++++

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

tests/qemu-iotests/group | 1 +

13 files changed, 133 insertions(+), 24 deletions(-)

create mode 100755 tests/qemu-iotests/248

create mode 100644 tests/qemu-iotests/248.out

If qemu-img convert sees that the target image isn't zero-initialised

yet, it tries to do an efficient zero write for the whole image first

to save the overhead of repeated explicit zero writes during the

conversion. Obviously, this provides only an advantage if the

pre-zeroing is actually efficient. Otherwise, we can end up writing

zeroes slowly while zeroing out the whole image, and then overwrite the

same blocks again with real data, potentially doubling the written data.

Pass BDRV_REQ_NO_FALLBACK to blk_make_zero() to avoid this case. If we

can't efficiently zero out, we'll instead write explicit zeroes only if

there is no data to be written to a block.

qemu-img.c | 2 +-

1 file changed, 1 insertion(+), 1 deletion(-)

@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)

if (!s->has_zero_init && !s->target_has_backing &&

bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))

{

- ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP);

+ ret = blk_make_zero(s->target, BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK);

if (ret == 0) {

s->has_zero_init = true;

}

2.20.1

Test that mirror job actually resume on resume command after being

automatically paused on ENOSPC error.

It's a follow-up test for 8d9648cbf3e

"blockjob: fix user pause in block_job_error_action"

tests/qemu-iotests/248 | 71 ++++++++++++++++++++++++++++++++++++++

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

tests/qemu-iotests/group | 1 +

3 files changed, 80 insertions(+)

create mode 100755 tests/qemu-iotests/248

create mode 100644 tests/qemu-iotests/248.out

diff --git a/tests/qemu-iotests/248 b/tests/qemu-iotests/248

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/248

+#!/usr/bin/env python

+#

+# Test resume mirror after auto pause on ENOSPC

+#

+# Copyright (c) 2019 Virtuozzo International GmbH. All rights reserved.

+#

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

+#

+import iotests

+from iotests import qemu_img_create, qemu_io, file_path, filter_qmp_testfiles

+iotests.verify_image_format(supported_fmts=['qcow2'])

+source, target = file_path('source', 'target')

+size = 5 * 1024 * 1024

+limit = 2 * 1024 * 1024

+qemu_img_create('-f', iotests.imgfmt, source, str(size))

+qemu_img_create('-f', iotests.imgfmt, target, str(size))

+qemu_io('-c', 'write 0 {}'.format(size), source)

+# raw format don't like empty files

+qemu_io('-c', 'write 0 {}'.format(size), target)

+vm = iotests.VM().add_drive(source)

+vm.launch()

+blockdev_opts = {

+ 'driver': iotests.imgfmt,

+ 'node-name': 'target',

+ 'file': {

+ 'driver': 'raw',

+ 'size': limit,

+ 'file': {

+ 'driver': 'file',

+ 'filename': target

+ }

+vm.qmp_log('blockdev-mirror', device='drive0', sync='full', target='target',

+ on_target_error='enospc')

+

+vm.event_wait('JOB_STATUS_CHANGE', timeout=3.0,

+ match={'data': {'status': 'paused'}})

+

+# drop other cached events, to not interfere with further wait for 'running'

+vm.get_qmp_events()

+

+del blockdev_opts['file']['size']

+vm.qmp_log('x-blockdev-reopen', filters=[filter_qmp_testfiles],

+ **blockdev_opts)

+

+vm.qmp_log('block-job-resume', device='drive0')

+vm.event_wait('JOB_STATUS_CHANGE', timeout=1.0,

+ match={'data': {'status': 'running'}})

+

+vm.shutdown()

diff --git a/tests/qemu-iotests/248.out b/tests/qemu-iotests/248.out

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/248.out

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

+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-target"}, "size": 2097152}, "node-name": "target"}}

+{"return": {}}

+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "on-target-error": "enospc", "sync": "full", "target": "target"}}

+{"return": {}}

+{"execute": "x-blockdev-reopen", "arguments": {"driver": "qcow2", "file": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-target"}}, "node-name": "target"}}

+{"return": {}}

+{"execute": "block-job-resume", "arguments": {"device": "drive0"}}

+{"return": {}}

diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/group

+++ b/tests/qemu-iotests/group

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

245 rw auto

246 rw auto quick

247 rw auto quick

+248 rw auto quick

2.20.1

For qemu-img convert, we want an operation that zeroes out the whole

image if this can be done efficiently, but that returns an error

otherwise so we don't write explicit zeroes and immediately overwrite

them with the real data, potentially doubling the amount of data to be

written.

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

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

2 files changed, 17 insertions(+), 2 deletions(-)

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

*/

BDRV_REQ_SERIALISING = 0x80,

+ /* Execute the request only if the operation can be offloaded or otherwise

+ * be executed efficiently, but return an error instead of using a slow

+ * fallback. */

+ BDRV_REQ_NO_FALLBACK = 0x100,

/* Mask of valid flags */

- BDRV_REQ_MASK = 0xff,

+ BDRV_REQ_MASK = 0x1ff,

} BdrvRequestFlags;

typedef struct BlockSizes {

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

--- a/block/io.c

+++ b/block/io.c

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

unsigned int nb_sectors;

assert(!(flags & ~BDRV_REQ_MASK));

+ assert(!(flags & BDRV_REQ_NO_FALLBACK));

if (!drv) {

return -ENOMEDIUM;

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

int ret;

assert(!(flags & ~BDRV_REQ_MASK));

+ assert(!(flags & BDRV_REQ_NO_FALLBACK));

if (!drv) {

return -ENOMEDIUM;

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

return -ENOMEDIUM;

}

+ if ((flags & ~bs->supported_zero_flags) & BDRV_REQ_NO_FALLBACK) {

+ return -ENOTSUP;

+ }

+

assert(alignment % bs->bl.request_alignment == 0);

head = offset % alignment;

tail = (offset + bytes) % alignment;

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

assert(!bs->supported_zero_flags);

}

- if (ret == -ENOTSUP) {

+ if (ret == -ENOTSUP && !(flags & BDRV_REQ_NO_FALLBACK)) {

/* Fall back to bounce buffer if write zeroes is unsupported */

BdrvRequestFlags write_flags = flags & ~BDRV_REQ_ZERO_WRITE;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_copy_range_internal(

BdrvTrackedRequest req;

int ret;

+ /* TODO We can support BDRV_REQ_NO_FALLBACK here */

+ assert(!(read_flags & BDRV_REQ_NO_FALLBACK));

+ assert(!(write_flags & BDRV_REQ_NO_FALLBACK));

+

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

return -ENOMEDIUM;

}

2.20.1

This makes the new BDRV_REQ_NO_FALLBACK flag available in the qemu-io

write command.

qemu-io-cmds.c | 13 +++++++++++--

1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c

--- a/qemu-io-cmds.c

+++ b/qemu-io-cmds.c

@@ -XXX,XX +XXX,XX @@ static void write_help(void)

" -b, -- write to the VM state rather than the virtual disk\n"

" -c, -- write compressed data with blk_write_compressed\n"

" -f, -- use Force Unit Access semantics\n"

+" -n, -- with -z, don't allow slow fallback\n"

" -p, -- ignored for backwards compatibility\n"

" -P, -- use different pattern to fill file\n"

" -C, -- report statistics in a machine parsable format\n"

@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t write_cmd = {

.perm = BLK_PERM_WRITE,

.argmin = 2,

.argmax = -1,

- .args = "[-bcCfquz] [-P pattern] off len",

+ .args = "[-bcCfnquz] [-P pattern] off len",

.oneline = "writes a number of bytes at a specified offset",

.help = write_help,

};

@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)

int64_t total = 0;

int pattern = 0xcd;

- while ((c = getopt(argc, argv, "bcCfpP:quz")) != -1) {

+ while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {

switch (c) {

case 'b':

bflag = true;

@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)

case 'f':

flags |= BDRV_REQ_FUA;

break;

+ case 'n':

+ flags |= BDRV_REQ_NO_FALLBACK;

+ break;

case 'p':

/* Ignored for backwards compatibility */

break;

@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)

return -EINVAL;

+ if ((flags & BDRV_REQ_NO_FALLBACK) && !zflag) {

+ printf("-n requires -z to be specified\n");

+ return -EINVAL;

if ((flags & BDRV_REQ_MAY_UNMAP) && !zflag) {

printf("-u requires -z to be specified\n");

return -EINVAL;

2.20.1