The following changes since commit ad88e4252f09c2956b99c90de39e95bab2e8e7af:

Merge remote-tracking branch 'remotes/amarkovic/tags/mips-queue-jun-1-2019' into staging (2019-06-03 10:25:12 +0100)

for you to fetch changes up to 9593db8ccd27800ce4a17f1d5b735b9130c541a2:

iotests: Fix duplicated diff output on failure (2019-06-03 16:33:20 +0200)

- block: AioContext management, part 2

- Avoid recursive block_status call (i.e. lseek() calls) if possible

- linux-aio: Drop unused BlockAIOCB submission method

- nvme: add Get/Set Feature Timestamp support

- Fix crash on commit job start with active I/O on base node

- Fix crash in bdrv_drained_end

- Fix integer overflow in qcow2 discard

John Snow (1):

blockdev: fix missed target unref for drive-backup

Julia Suvorova (1):

block/linux-aio: Drop unused BlockAIOCB submission method

Kenneth Heitke (1):

nvme: add Get/Set Feature Timestamp support

Kevin Wolf (19):

block: Drain source node in bdrv_replace_node()

iotests: Test commit job start with concurrent I/O

test-block-iothread: Check filter node in test_propagate_mirror

nbd-server: Call blk_set_allow_aio_context_change()

block: Add Error to blk_set_aio_context()

block: Add BlockBackend.ctx

block: Add qdev_prop_drive_iothread property type

scsi-disk: Use qdev_prop_drive_iothread

block: Adjust AioContexts when attaching nodes

test-block-iothread: Test adding parent to iothread node

test-block-iothread: BlockBackend AioContext across root node change

block: Move node without parents to main AioContext

blockdev: Use bdrv_try_set_aio_context() for monitor commands

block: Remove wrong bdrv_set_aio_context() calls

virtio-scsi-test: Test attaching new overlay with iothreads

iotests: Attach new devices to node in non-default iothread

test-bdrv-drain: Use bdrv_try_set_aio_context()

block: Remove bdrv_set_aio_context()

iotests: Fix duplicated diff output on failure

Max Reitz (2):

block/io: Delay decrementing the quiesce_counter

iotests: Test cancelling a job and closing the VM

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

Let's at least trace ignored failure.

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

block/qcow2-refcount.c | 7 ++++++-

block/trace-events | 3 +++

2 files changed, 9 insertions(+), 1 deletion(-)

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

--- a/block/qcow2-refcount.c

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

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

#include "qemu/range.h"

#include "qemu/bswap.h"

#include "qemu/cutils.h"

+#include "trace.h"

static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size,

uint64_t max);

@@ -XXX,XX +XXX,XX @@ void qcow2_process_discards(BlockDriverState *bs, int ret)

/* Discard is optional, ignore the return value */

if (ret >= 0) {

- bdrv_pdiscard(bs->file, d->offset, d->bytes);

+ int r2 = bdrv_pdiscard(bs->file, d->offset, d->bytes);

+ if (r2 < 0) {

+ trace_qcow2_process_discards_failed_region(d->offset, d->bytes,

+ r2);

+ }

}

g_free(d);

diff --git a/block/trace-events b/block/trace-events

index XXXXXXX..XXXXXXX 100644

--- a/block/trace-events

+++ b/block/trace-events

@@ -XXX,XX +XXX,XX @@ qcow2_cache_get_done(void *co, int c, int i) "co %p is_l2_cache %d index %d"

qcow2_cache_flush(void *co, int c) "co %p is_l2_cache %d"

qcow2_cache_entry_flush(void *co, int c, int i) "co %p is_l2_cache %d index %d"

+# qcow2-refcount.c

+qcow2_process_discards_failed_region(uint64_t offset, uint64_t bytes, int ret) "offset 0x%" PRIx64 " bytes 0x%" PRIx64 " ret %d"

# qed-l2-cache.c

qed_alloc_l2_cache_entry(void *l2_cache, void *entry) "l2_cache %p entry %p"

qed_unref_l2_cache_entry(void *entry, int ref) "entry %p ref %d"

2.20.1

Commit 70ff5b07 wanted to move the diff between actual and reference

output to the end after printing the test result line. It really only

copied it, though, so the diff is now displayed twice. Remove the old

one.

Fixes: 70ff5b07fcdd378180ad2d5cc0b0d5e67e7ef325

tests/qemu-iotests/check | 1 -

1 file changed, 1 deletion(-)

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

--- a/tests/qemu-iotests/check

+++ b/tests/qemu-iotests/check

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

fi

else

mv $tmp.out $seq.out.bad

- $diff -w "$reference" "$PWD"/$seq.out.bad

status="fail"

results="output mismatch (see $seq.out.bad)"

printdiff=true

2.20.1

A node should only be in a non-default AioContext if a user is attached

to it that requires this. When the last parent of a node is gone, it can

move back to the main AioContext.

block.c | 4 ++++

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

tests/test-block-iothread.c | 3 +--

3 files changed, 6 insertions(+), 3 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)

bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm);

bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL, &error_abort);

bdrv_set_perm(old_bs, perm, shared_perm);

+

+ /* When the parent requiring a non-default AioContext is removed, the

+ * node moves back to the main AioContext */

+ bdrv_try_set_aio_context(old_bs, qemu_get_aio_context(), NULL);

if (new_bs) {

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c

index XXXXXXX..XXXXXXX 100644

--- a/tests/test-bdrv-drain.c

+++ b/tests/test-bdrv-drain.c

@@ -XXX,XX +XXX,XX @@ static void test_blockjob_common_drain_node(enum drain_type drain_type,

if (use_iothread) {

blk_set_aio_context(blk_src, qemu_get_aio_context(), &error_abort);

- blk_set_aio_context(blk_target, qemu_get_aio_context(), &error_abort);

+ assert(blk_get_aio_context(blk_target) == qemu_get_aio_context());

}

aio_context_release(ctx);

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

/* Remove the node again */

blk_remove_bs(blk);

- /* TODO bs should move back to main context here */

g_assert(blk_get_aio_context(blk) == ctx);

- g_assert(bdrv_get_aio_context(bs) == ctx);

+ g_assert(bdrv_get_aio_context(bs) == qemu_get_aio_context());

/* Re-attach the node */

blk_insert_bs(blk, bs, &error_abort);

2.20.1

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

drv_co_block_status digs bs->file for additional, more accurate search

for hole inside region, reported as DATA by bs since 5daa74a6ebc.

This accuracy is not free: assume we have qcow2 disk. Actually, qcow2

knows, where are holes and where is data. But every block_status

request calls lseek additionally. Assume a big disk, full of

data, in any iterative copying block job (or img convert) we'll call

lseek(HOLE) on every iteration, and each of these lseeks will have to

iterate through all metadata up to the end of file. It's obviously

ineffective behavior. And for many scenarios we don't need this lseek

at all.

However, lseek is needed when we have metadata-preallocated image.

So, let's detect metadata-preallocation case and don't dig qcow2's

protocol file in other cases.

The idea is to compare allocation size in POV of filesystem with

allocations size in POV of Qcow2 (by refcounts). If allocation in fs is

significantly lower, consider it as metadata-preallocation case.

102 iotest changed, as our detector can't detect shrinked file as

metadata-preallocation, which don't seem to be wrong, as with metadata

preallocation we always have valid file length.

Two other iotests have a slight change in their QMP output sequence:

Active 'block-commit' returns earlier because the job coroutine yields

earlier on a blocking operation. This operation is loading the refcount

blocks in qcow2_detect_metadata_preallocation().

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

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

block/qcow2.h | 4 ++++

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

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

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

block/qcow2.c | 11 +++++++++++

tests/qemu-iotests/102 | 2 +-

tests/qemu-iotests/102.out | 3 ++-

tests/qemu-iotests/141.out | 2 +-

tests/qemu-iotests/144.out | 2 +-

9 files changed, 67 insertions(+), 6 deletions(-)

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

* BDRV_BLOCK_EOF: the returned pnum covers through end of file for this

* layer, set by block layer

*

- * Internal flag:

+ * Internal flags:

* BDRV_BLOCK_RAW: for use by passthrough drivers, such as raw, to request

* that the block layer recompute the answer from the returned

* BDS; must be accompanied by just BDRV_BLOCK_OFFSET_VALID.

+ * BDRV_BLOCK_RECURSE: request that the block layer will recursively search for

+ * zeroes in file child of current block node inside

+ * returned region. Only valid together with both

+ * BDRV_BLOCK_DATA and BDRV_BLOCK_OFFSET_VALID. Should not

+ * appear with BDRV_BLOCK_ZERO.

*

* If BDRV_BLOCK_OFFSET_VALID is set, the map parameter represents the

* host offset within the returned BDS that is allocated for the

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

#define BDRV_BLOCK_RAW 0x08

#define BDRV_BLOCK_ALLOCATED 0x10

#define BDRV_BLOCK_EOF 0x20

+#define BDRV_BLOCK_RECURSE 0x40

#define BDRV_BLOCK_OFFSET_MASK BDRV_SECTOR_MASK

typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;

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

*/

assert(*pnum && QEMU_IS_ALIGNED(*pnum, align) &&

align > offset - aligned_offset);

+ if (ret & BDRV_BLOCK_RECURSE) {

+ assert(ret & BDRV_BLOCK_DATA);

+ assert(ret & BDRV_BLOCK_OFFSET_VALID);

+ assert(!(ret & BDRV_BLOCK_ZERO));

+ }

+

*pnum -= offset - aligned_offset;

if (*pnum > bytes) {

*pnum = bytes;

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

}

}

- if (want_zero && local_file && local_file != bs &&

+ if (want_zero && ret & BDRV_BLOCK_RECURSE &&

+ local_file && local_file != bs &&

(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&

(ret & BDRV_BLOCK_OFFSET_VALID)) {

int64_t file_pnum;

@@ -XXX,XX +XXX,XX @@ int64_t qcow2_get_last_cluster(BlockDriverState *bs, int64_t size)

"There are no references in the refcount table.");

return -EIO;

}

+

+int qcow2_detect_metadata_preallocation(BlockDriverState *bs)

+{

+ BDRVQcow2State *s = bs->opaque;

+ int64_t i, end_cluster, cluster_count = 0, threshold;

+ int64_t file_length, real_allocation, real_clusters;

+

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

+ if (file_length < 0) {

+ return file_length;

+ }

+

+ real_allocation = bdrv_get_allocated_file_size(bs->file->bs);

+ if (real_allocation < 0) {

+ return real_allocation;

+ }

+

+ real_clusters = real_allocation / s->cluster_size;

+ threshold = MAX(real_clusters * 10 / 9, real_clusters + 2);

+

+ end_cluster = size_to_clusters(s, file_length);

+ for (i = 0; i < end_cluster && cluster_count < threshold; i++) {

+ uint64_t refcount;

+ int ret = qcow2_get_refcount(bs, i, &refcount);

+ if (ret < 0) {

+ return ret;

+ }

+ cluster_count += !!refcount;

+ }

+

+ return cluster_count >= threshold;

+}

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

unsigned int bytes;

int status = 0;

+ if (!s->metadata_preallocation_checked) {

+ ret = qcow2_detect_metadata_preallocation(bs);

+ s->metadata_preallocation = (ret == 1);

+ s->metadata_preallocation_checked = true;

+ }

+

bytes = MIN(INT_MAX, count);

qemu_co_mutex_lock(&s->lock);

ret = qcow2_get_cluster_offset(bs, offset, &bytes, &cluster_offset);

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

} else if (ret != QCOW2_CLUSTER_UNALLOCATED) {

status |= BDRV_BLOCK_DATA;

}

+ if (s->metadata_preallocation && (status & BDRV_BLOCK_DATA) &&

+ (status & BDRV_BLOCK_OFFSET_VALID))

+ {

+ status |= BDRV_BLOCK_RECURSE;

+ }

return status;

}

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/102

+++ b/tests/qemu-iotests/102

@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write 0 64k' "$TEST_IMG" | _filter_qemu_io

$QEMU_IMG resize -f raw --shrink "$TEST_IMG" $((5 * 64 * 1024))

$QEMU_IO -c map "$TEST_IMG"

-$QEMU_IMG map "$TEST_IMG"

+$QEMU_IMG map "$TEST_IMG" | _filter_qemu_img_map

echo

echo '=== Testing map on an image file truncated outside of qemu ==='

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

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/102.out

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

@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 0

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

Image resized.

64 KiB (0x10000) bytes allocated at offset 0 bytes (0x0)

-Offset Length Mapped to File

+Offset Length File

+0 0x10000 TEST_DIR/t.IMGFMT

=== Testing map on an image file truncated outside of qemu ===

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

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/141.out

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

@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/o.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.

{"return": {}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}

+{"return": {}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "ready", "id": "job0"}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}}

-{"return": {}}

{"error": {"class": "GenericError", "desc": "Node 'drv0' is busy: block device is in use by block job: commit"}}

{"return": {}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}}

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

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/144.out

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

@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/tmp.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "virtio0"}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "virtio0"}}

+{"return": {}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "ready", "id": "virtio0"}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "virtio0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}}

{"return": {}}

-{"return": {}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "virtio0"}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "pending", "id": "virtio0"}}

{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "virtio0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}}

2.20.1

This adds a new parameter to blk_new() which requires its callers to

declare from which AioContext this BlockBackend is going to be used (or

the locks of which AioContext need to be taken anyway).

The given context is only stored and kept up to date when changing

AioContexts. Actually applying the stored AioContext to the root node

is saved for another commit.

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

block.c | 2 +-

block/backup.c | 3 ++-

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

block/commit.c | 11 +++++++----

block/crypto.c | 3 ++-

block/mirror.c | 3 ++-

block/parallels.c | 3 ++-

block/qcow.c | 3 ++-

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

block/qed.c | 3 ++-

block/sheepdog.c | 3 ++-

block/vdi.c | 3 ++-

block/vhdx.c | 3 ++-

block/vmdk.c | 3 ++-

block/vpc.c | 3 ++-

blockdev.c | 4 ++--

blockjob.c | 2 +-

hmp.c | 3 ++-

hw/block/fdc.c | 2 +-

hw/block/xen-block.c | 2 +-

hw/core/qdev-properties-system.c | 4 +++-

hw/ide/qdev.c | 2 +-

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

migration/block.c | 3 ++-

nbd/server.c | 5 +++--

qemu-img.c | 6 ++++--

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

tests/test-bdrv-graph-mod.c | 5 +++--

tests/test-block-backend.c | 6 ++++--

tests/test-block-iothread.c | 10 +++++-----

tests/test-blockjob.c | 2 +-

tests/test-throttle.c | 6 +++---

33 files changed, 102 insertions(+), 64 deletions(-)

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

ThrottleGroupMember throttle_group_member;

} BlockBackendPublic;

-BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm);

+BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm);

BlockBackend *blk_new_open(const char *filename, const char *reference,

QDict *options, int flags, Error **errp);

int blk_get_refcnt(BlockBackend *blk);

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

/* Not requesting BLK_PERM_CONSISTENT_READ because we're only

* looking at the header to guess the image format. This works even

* in cases where a guest would not see a consistent state. */

- file = blk_new(0, BLK_PERM_ALL);

+ file = blk_new(bdrv_get_aio_context(file_bs), 0, BLK_PERM_ALL);

blk_insert_bs(file, file_bs, &local_err);

bdrv_unref(file_bs);

if (local_err) {

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

index XXXXXXX..XXXXXXX 100644

--- a/block/backup.c

+++ b/block/backup.c

@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,

}

/* The target must match the source in size, so no resize here either */

- job->target = blk_new(BLK_PERM_WRITE,

+ job->target = blk_new(job->common.job.aio_context,

+ BLK_PERM_WRITE,

BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE |

BLK_PERM_WRITE_UNCHANGED | BLK_PERM_GRAPH_MOD);

ret = blk_insert_bs(job->target, target, errp);

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

char *name;

int refcnt;

BdrvChild *root;

+ AioContext *ctx;

DriveInfo *legacy_dinfo; /* null unless created by drive_new() */

QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */

QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */

@@ -XXX,XX +XXX,XX @@ static const BdrvChildRole child_root = {

*

* Return the new BlockBackend on success, null on failure.

*/

-BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm)

+BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)

BlockBackend *blk;

blk = g_new0(BlockBackend, 1);

blk->refcnt = 1;

+ blk->ctx = ctx;

blk->perm = perm;

blk->shared_perm = shared_perm;

blk_set_enable_write_cache(blk, true);

@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm)

/*

* Creates a new BlockBackend, opens a new BlockDriverState, and connects both.

+ * The new BlockBackend is in the main AioContext.

*

* Just as with bdrv_open(), after having called this function the reference to

* @options belongs to the block layer (even on failure).

@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_new_open(const char *filename, const char *reference,

perm |= BLK_PERM_RESIZE;

}

- blk = blk_new(perm, BLK_PERM_ALL);

+ blk = blk_new(qemu_get_aio_context(), perm, BLK_PERM_ALL);

bs = bdrv_open(filename, reference, options, flags, errp);

if (!bs) {

blk_unref(blk);

@@ -XXX,XX +XXX,XX @@ void blk_op_unblock_all(BlockBackend *blk, Error *reason)

AioContext *blk_get_aio_context(BlockBackend *blk)

{

- return bdrv_get_aio_context(blk_bs(blk));

+ BlockDriverState *bs = blk_bs(blk);

+

+ /* FIXME The AioContext of bs and blk can be inconsistent. For the moment,

+ * we prefer the one of bs for compatibility. */

+ if (bs) {

+ return bdrv_get_aio_context(blk_bs(blk));

+ }

+

+ return blk->ctx;

static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)

@@ -XXX,XX +XXX,XX @@ static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,

}

}

+ blk->ctx = new_context;

return 0;

}

@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,

goto fail;

}

- s->base = blk_new(BLK_PERM_CONSISTENT_READ

+ s->base = blk_new(s->common.job.aio_context,

+ BLK_PERM_CONSISTENT_READ

| BLK_PERM_WRITE

| BLK_PERM_RESIZE,

BLK_PERM_CONSISTENT_READ

@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,

s->base_bs = base;