The following changes since commit 63f495beb4007de5444614125fd6fd178ca6e2b1:

Merge remote-tracking branch 'remotes/kraxel/tags/pull-cve-2017-2620-20170224-1' into staging (2017-02-24 13:55:26 +0000)

are available in the git repository at:

for you to fetch changes up to d185cf0ec64cd183218ca7e0810d9130c96ebebc:

tests: Use opened block node for block job tests (2017-02-24 16:09:23 +0100)

Block layer patches

Jeff Cody (3):

qemu-iotests: Test 137 only supports 'file' protocol

qemu-iotests: add ability to exclude certain protocols from tests

qemu-iotests: redirect nbd server stdout to /dev/null

John Snow (1):

iotests: Fix another race in 030

Kevin Wolf (11):

blockdev: Use BlockBackend to resize in qmp_block_resize()

qcow2: Use BB for resizing in qcow2_amend_options()

mirror: Resize active commit base in mirror_run()

block: Pass BdrvChild to bdrv_truncate()

block: Attach bs->file only during .bdrv_open()

block: Factor out bdrv_open_child_bs()

block: Use BlockBackend for image probing

block: Factor out bdrv_open_driver()

block: Add bdrv_new_open_driver()

vvfat: Use opened node as backing file

tests: Use opened block node for block job tests

Nir Soffer (4):

qemu-img: Do not truncate before preallocation

qemu-img: Add tests for raw image preallocation

qemu-img: Truncate before full preallocation

qemu-img: Improve documentation for PREALLOC_MODE_FALLOC

block.c | 265 +++++++++++++++++++++++++++---------------

block/blkdebug.c | 2 +-

block/block-backend.c | 2 +-

block/bochs.c | 6 +

block/cloop.c | 6 +

block/crypto.c | 8 +-

block/dmg.c | 6 +

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

block/mirror.c | 50 ++++----

block/parallels.c | 14 ++-

block/qcow.c | 10 +-

block/qcow2-refcount.c | 2 +-

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

block/qed.c | 18 ++-

block/raw-format.c | 8 +-

block/replication.c | 6 +

block/vdi.c | 6 +

block/vhdx-log.c | 2 +-

block/vhdx.c | 8 +-

block/vmdk.c | 6 +

block/vpc.c | 6 +

block/vvfat.c | 10 +-

blockdev.c | 7 +-

include/block/block.h | 4 +-

tests/qemu-iotests/030 | 5 +-

tests/qemu-iotests/051.out | 4 +-

tests/qemu-iotests/051.pc.out | 4 +-

tests/qemu-iotests/137 | 2 +-

tests/qemu-iotests/175 | 61 ++++++++++

tests/qemu-iotests/175.out | 18 +++

tests/qemu-iotests/common.rc | 14 ++-

tests/qemu-iotests/group | 1 +

tests/test-blockjob-txn.c | 6 +-

tests/test-blockjob.c | 6 +-

34 files changed, 461 insertions(+), 168 deletions(-)

create mode 100755 tests/qemu-iotests/175

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

From: Jeff Cody <jcody@redhat.com>

Some iotests (e.g. 174) try to filter the output of _make_test_image by

piping the stdout. Pipe the server stdout to /dev/null, so that filter

pipe does not need to wait until process completion.

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

tests/qemu-iotests/common.rc | 2 +-

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

diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc

--- a/tests/qemu-iotests/common.rc

+++ b/tests/qemu-iotests/common.rc

@@ -XXX,XX +XXX,XX @@ _make_test_img()

# Start an NBD server on the image file, which is what we'll be talking to

if [ $IMGPROTO = "nbd" ]; then

- eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT $TEST_IMG_FILE &"

+ eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT $TEST_IMG_FILE >/dev/null &"

sleep 1 # FIXME: qemu-nbd needs to be listening before we continue

fi

}

1.8.3.1

From: John Snow <jsnow@redhat.com>

We can't rely on a non-paused job to be present and running for us.

Assume that if the job is not present that it completed already.

Signed-off-by: John Snow <jsnow@redhat.com>

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

tests/qemu-iotests/030 | 5 ++++-

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

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

--- a/tests/qemu-iotests/030

+++ b/tests/qemu-iotests/030

@@ -XXX,XX +XXX,XX @@ class TestEIO(TestErrors):

while not completed:

for event in self.vm.get_qmp_events(wait=True):

if event['event'] == 'BLOCK_JOB_ERROR':

+ error = True

self.assert_qmp(event, 'data/device', 'drive0')

self.assert_qmp(event, 'data/operation', 'read')

result = self.vm.qmp('query-block-jobs')

+ if result == {'return': []}:

+ # Job finished too quickly

+ continue

self.assert_qmp(result, 'return[0]/paused', False)

- error = True

elif event['event'] == 'BLOCK_JOB_COMPLETED':

self.assertTrue(error, 'job completed unexpectedly')

self.assert_qmp(event, 'data/type', 'stream')

1.8.3.1

From: Nir Soffer <nirsof@gmail.com>

In a previous commit (qemu-img: Do not truncate before preallocation) we

moved truncate to the PREALLOC_MODE_OFF branch to avoid slowdown in

posix_fallocate().

However this change is not optimal when using PREALLOC_MODE_FULL, since

knowing the final size from the beginning could allow the file system

driver to do less allocations and possibly avoid fragmentation of the

file.

Now we truncate also before doing full preallocation.

Signed-off-by: Nir Soffer <nirsof@gmail.com>

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

1 file changed, 12 insertions(+)

@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)

#endif

case PREALLOC_MODE_FULL:

{

+ /*

+ * Knowing the final size from the beginning could allow the file

+ * system driver to do less allocations and possibly avoid

+ * fragmentation of the file.

+ */

+ if (ftruncate(fd, total_size) != 0) {

+ result = -errno;

+ error_setg_errno(errp, -result, "Could not resize file");

+ goto out_close;

+

int64_t num = 0, left = total_size;

buf = g_malloc0(65536);

@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)

break;

}

+out_close:

if (qemu_close(fd) != 0 && result == 0) {

result = -errno;

error_setg_errno(errp, -result, "Could not close the new file");

1.8.3.1

block.c | 3 ++-

block/blkdebug.c | 2 +-

block/block-backend.c | 2 +-

block/crypto.c | 2 +-

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

block/qcow.c | 4 ++--

block/qcow2-refcount.c | 2 +-

block/qcow2.c | 4 ++--

block/raw-format.c | 2 +-

block/vhdx-log.c | 2 +-

block/vhdx.c | 2 +-

include/block/block.h | 2 +-

12 files changed, 18 insertions(+), 17 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

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

/**

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

*/

-int bdrv_truncate(BlockDriverState *bs, int64_t offset)

+int bdrv_truncate(BdrvChild *child, int64_t offset)

{

+ BlockDriverState *bs = child->bs;

BlockDriver *drv = bs->drv;

int ret;

if (!drv)

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

index XXXXXXX..XXXXXXX 100644

--- a/block/blkdebug.c

+++ b/block/blkdebug.c

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

static int blkdebug_truncate(BlockDriverState *bs, int64_t offset)

{

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

+ return bdrv_truncate(bs->file, offset);

}

static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)

@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset)

- return bdrv_truncate(blk_bs(blk), offset);

+ return bdrv_truncate(blk->root, offset);

}

static void blk_pdiscard_entry(void *opaque)

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

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

+ return bdrv_truncate(bs->file, offset);

}

- ret = bdrv_truncate(bs->file->bs,

+ ret = bdrv_truncate(bs->file,

(s->data_end + space) << BDRV_SECTOR_BITS);

@@ -XXX,XX +XXX,XX @@ static int parallels_check(BlockDriverState *bs, BdrvCheckResult *res,

size - res->image_end_offset);

res->leaks += count;

if (fix & BDRV_FIX_LEAKS) {

- ret = bdrv_truncate(bs->file->bs, res->image_end_offset);

+ ret = bdrv_truncate(bs->file, res->image_end_offset);

}

if (bs->open_flags & BDRV_O_RDWR) {

- bdrv_truncate(bs->file->bs, s->data_end << BDRV_SECTOR_BITS);

+ bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS);

}

@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,

/* round to cluster size */

cluster_offset = (cluster_offset + s->cluster_size - 1) &

~(s->cluster_size - 1);

- bdrv_truncate(bs->file->bs, cluster_offset + s->cluster_size);

+ bdrv_truncate(bs->file, cluster_offset + s->cluster_size);

/* if encrypted, we must initialize the cluster

content which won't be written */

if (bs->encrypted &&

- ret = bdrv_truncate(bs->file->bs, s->l1_table_offset + l1_length);

+ ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);

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

/* align end of file to a sector boundary to ease reading with

sector based I/Os */

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

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

+ return bdrv_truncate(bs->file, cluster_offset);

}

buf = qemu_blockalign(bs, s->cluster_size);

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

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

+ return bdrv_truncate(bs->file, offset);

}

static int raw_media_changed(BlockDriverState *bs)

if (new_file_size % (1024*1024)) {

/* round up to nearest 1MB boundary */

new_file_size = ((new_file_size >> 20) + 1) << 20;

- bdrv_truncate(bs->file->bs, new_file_size);

+ bdrv_truncate(bs->file, new_file_size);

}

}

qemu_vfree(desc_entries);

/* per the spec, the address for a block is in units of 1MB */

*new_offset = ROUND_UP(*new_offset, 1024 * 1024);

- return bdrv_truncate(bs->file->bs, *new_offset + s->block_size);

+ return bdrv_truncate(bs->file, *new_offset + s->block_size);

}

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

index XXXXXXX..XXXXXXX 100644

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

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

@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,

const char *backing_file);

int bdrv_get_backing_file_depth(BlockDriverState *bs);

void bdrv_refresh_filename(BlockDriverState *bs);

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

+int bdrv_truncate(BdrvChild *child, int64_t offset);

int64_t bdrv_nb_sectors(BlockDriverState *bs);

int64_t bdrv_getlength(BlockDriverState *bs);

int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);

1.8.3.1

The way that attaching bs->file worked was a bit unusual in that it was

the only child that would be attached to a node which is not opened yet.

Because of this, the block layer couldn't know yet which permissions the

driver would eventually need.

This patch moves the point where bs->file is attached to the beginning

of the individual .bdrv_open() implementations, so drivers already know

what they are going to do with the child. This is also more consistent

with how driver-specific children work.

For a moment, bdrv_open() gets its own BdrvChild to perform image

probing, but instead of directly assigning this BdrvChild to the BDS, it

becomes a temporary one and the node name is passed as an option to the

drivers, so that they can simply use bdrv_open_child() to create another

reference for their own use.

This duplicated child for (the not opened yet) bs is not the final

state, a follow-up patch will change the image probing code to use a

BlockBackend, which is completely independent of bs.

block.c | 35 ++++++++++++++++++++++++-----------

block/bochs.c | 6 ++++++

block/cloop.c | 6 ++++++

block/crypto.c | 6 ++++++

block/dmg.c | 6 ++++++

block/parallels.c | 6 ++++++

block/qcow.c | 6 ++++++

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

block/qed.c | 18 +++++++++++++++---

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

block/replication.c | 6 ++++++

block/vdi.c | 6 ++++++

block/vhdx.c | 6 ++++++

block/vmdk.c | 6 ++++++

block/vpc.c | 6 ++++++

tests/qemu-iotests/051.out | 4 ++--

tests/qemu-iotests/051.pc.out | 4 ++--

17 files changed, 130 insertions(+), 21 deletions(-)

@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,

assert(!drv->bdrv_needs_filename || filename != NULL);

ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);

} else {

- if (file == NULL) {

- error_setg(errp, "Can't use '%s' as a block driver for the "

- "protocol level", drv->format_name);

- ret = -EINVAL;

- goto free_and_fail;

- }

- bs->file = file;

ret = drv->bdrv_open(bs, options, open_flags, &local_err);

}

@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,

return 0;

free_and_fail:

- bs->file = NULL;

g_free(bs->opaque);

bs->opaque = NULL;

bs->drv = NULL;

@@ -XXX,XX +XXX,XX @@ void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)

}

if (child->bs->inherits_from == parent) {

- child->bs->inherits_from = NULL;

+ BdrvChild *c;

+

+ /* Remove inherits_from only when the last reference between parent and

+ * child->bs goes away. */

+ QLIST_FOREACH(c, &parent->children, next) {

+ if (c != child && c->bs == child->bs) {

+ break;

+ }

+ }

+ if (c == NULL) {

+ child->bs->inherits_from = NULL;

+ }

}

bdrv_root_unref_child(child);

@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,

qdict_del(options, "backing");

}

- /* Open image file without format layer */

+ /* Open image file without format layer. This BdrvChild is only used for

+ * probing, the block drivers will do their own bdrv_open_child() for the

+ * same BDS, which is why we put the node name back into options. */

if ((flags & BDRV_O_PROTOCOL) == 0) {

+ /* FIXME Shouldn't attach a child to a node that isn't opened yet. */

file = bdrv_open_child(filename, options, "file", bs,

&child_file, true, &local_err);

if (local_err) {

goto fail;

}

+ if (file != NULL) {

+ qdict_put(options, "file",

+ qstring_from_str(bdrv_get_node_name(file->bs)));

+ }

}

/* Image format probing */

@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,

goto fail;

}

- if (file && (bs->file != file)) {

+ if (file) {

bdrv_unref_child(bs, file);

file = NULL;

}

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

if (file != NULL) {

bdrv_unref_child(bs, file);

}

+ if (bs->file != NULL) {

+ bdrv_unref_child(bs, bs->file);

+ }

QDECREF(snapshot_options);

QDECREF(bs->explicit_options);

QDECREF(bs->options);

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

index XXXXXXX..XXXXXXX 100644

--- a/block/bochs.c

+++ b/block/bochs.c

@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,

struct bochs_header bochs;

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

bs->read_only = true; /* no write support yet */

ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));

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

index XXXXXXX..XXXXXXX 100644

--- a/block/cloop.c

+++ b/block/cloop.c

@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,

uint32_t offsets_size, max_compressed_block_size = 1, i;

int ret;

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

bs->read_only = true;

/* read header */

@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,

QCryptoBlockOpenOptions *open_opts = NULL;

unsigned int cflags = 0;

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);

qemu_opts_absorb_qdict(opts, options, &local_err);

if (local_err) {

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

index XXXXXXX..XXXXXXX 100644

--- a/block/dmg.c

+++ b/block/dmg.c

@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,

int64_t offset;

int ret;

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

block_module_load_one("dmg-bz2");

bs->read_only = true;

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

index XXXXXXX..XXXXXXX 100644

--- a/block/parallels.c

+++ b/block/parallels.c

@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,

Error *local_err = NULL;

char *buf;

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));

if (ret < 0) {

goto fail;

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow.c

+++ b/block/qcow.c

@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,

QCowHeader header;

Error *local_err = NULL;

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

ret = bdrv_pread(bs->file, 0, &header, sizeof(header));

if (ret < 0) {

goto fail;

@@ -XXX,XX +XXX,XX @@ static int qcow2_update_options(BlockDriverState *bs, QDict *options,

return ret;

}

-static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,

- Error **errp)

+static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,

+ Error **errp)

{

BDRVQcow2State *s = bs->opaque;

unsigned int len, i;

@@ -XXX,XX +XXX,XX @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,

return ret;

}

+static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,

+ Error **errp)

+{

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

+ return qcow2_do_open(bs, options, flags, errp);

+}

+

static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)

{

BDRVQcow2State *s = bs->opaque;

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

options = qdict_clone_shallow(bs->options);

flags &= ~BDRV_O_INACTIVE;

- ret = qcow2_open(bs, options, flags, &local_err);

+ ret = qcow2_do_open(bs, options, flags, &local_err);

QDECREF(options);

if (local_err) {

error_propagate(errp, local_err);

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

}

}

-static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,

- Error **errp)

+static int bdrv_qed_do_open(BlockDriverState *bs, QDict *options, int flags,

+ Error **errp)

{

BDRVQEDState *s = bs->opaque;

QEDHeader le_header;

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

return ret;

}

+static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,

+ Error **errp)

+{

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,

+ false, errp);

+ if (!bs->file) {

+ return -EINVAL;

+ }

+

+ return bdrv_qed_do_open(bs, options, flags, errp);