The following changes since commit 19b599f7664b2ebfd0f405fb79c14dd241557452:

Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2018-08-27-v2' into staging (2018-08-27 16:44:20 +0100)

https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2018-08-31-v2

for you to fetch changes up to e21a1c9831fc80ae3f3c1affdfa43350035d8588:

jobs: remove job_defer_to_main_loop (2018-08-31 16:28:33 +0200)

- (Block) job exit refactoring, part 1

(removing job_defer_to_main_loop())

- test-bdrv-drain leak fix

John Snow (9):

jobs: change start callback to run callback

jobs: canonize Error object

jobs: add exit shim

block/commit: utilize job_exit shim

block/mirror: utilize job_exit shim

jobs: utilize job_exit shim

block/backup: make function variables consistently named

jobs: remove ret argument to job_completed; privatize it

jobs: remove job_defer_to_main_loop

Marc-André Lureau (1):

tests: fix bdrv-drain leak

include/qemu/job.h | 70 ++++++++++++++++-----------------

block/backup.c | 81 ++++++++++++++++-----------------------

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

block/create.c | 19 +++------

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

block/stream.c | 29 ++++++--------

job-qmp.c | 5 ++-

job.c | 73 ++++++++++++-----------------------

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

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

tests/test-blockjob.c | 17 ++++----

trace-events | 2 +-

12 files changed, 161 insertions(+), 242 deletions(-)

2.17.1

From: John Snow <jsnow@redhat.com>

Now that the job infrastructure is handling the job_completed call for

all implemented jobs, we can remove the interface that allowed jobs to

schedule their own completion.

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

Reviewed-by: Max Reitz <mreitz@redhat.com>

Message-id: 20180830015734.19765-10-jsnow@redhat.com

include/qemu/job.h | 17 -----------------

job.c | 40 ++--------------------------------------

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

diff --git a/include/qemu/job.h b/include/qemu/job.h

--- a/include/qemu/job.h

+++ b/include/qemu/job.h

@@ -XXX,XX +XXX,XX @@ void job_finalize(Job *job, Error **errp);

*/

void job_dismiss(Job **job, Error **errp);

-typedef void JobDeferToMainLoopFn(Job *job, void *opaque);

-

-/**

- * @job: The job

- * @fn: The function to run in the main loop

- * @opaque: The opaque value that is passed to @fn

- *

- * This function must be called by the main job coroutine just before it

- * returns. @fn is executed in the main loop with the job AioContext acquired.

- *

- * Block jobs must call bdrv_unref(), bdrv_close(), and anything that uses

- * bdrv_drain_all() in the main loop.

- *

- * The @job AioContext is held while @fn executes.

- */

-void job_defer_to_main_loop(Job *job, JobDeferToMainLoopFn *fn, void *opaque);

-

/**

* Synchronously finishes the given @job. If @finish is given, it is called to

* trigger completion or cancellation of the job.

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

index XXXXXXX..XXXXXXX 100644

--- a/job.c

+++ b/job.c

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

assert(job && job->driver && job->driver->run);

job_pause_point(job);

job->ret = job->driver->run(job, &job->err);

- if (!job->deferred_to_main_loop) {

- job->deferred_to_main_loop = true;

- aio_bh_schedule_oneshot(qemu_get_aio_context(),

- job_exit,

- job);

- }

+ job->deferred_to_main_loop = true;

+ aio_bh_schedule_oneshot(qemu_get_aio_context(), job_exit, job);

}

@@ -XXX,XX +XXX,XX @@ void job_complete(Job *job, Error **errp)

job->driver->complete(job, errp);

}

-

-typedef struct {

- Job *job;

- JobDeferToMainLoopFn *fn;

- void *opaque;

-} JobDeferToMainLoopData;

-

-static void job_defer_to_main_loop_bh(void *opaque)

-{

- JobDeferToMainLoopData *data = opaque;

- Job *job = data->job;

- AioContext *aio_context = job->aio_context;

-

- aio_context_acquire(aio_context);

- data->fn(data->job, data->opaque);

- aio_context_release(aio_context);

-

- g_free(data);

-}

-

-void job_defer_to_main_loop(Job *job, JobDeferToMainLoopFn *fn, void *opaque)

-{

- JobDeferToMainLoopData *data = g_malloc(sizeof(*data));

- data->job = job;

- data->fn = fn;

- data->opaque = opaque;

- job->deferred_to_main_loop = true;

-

- aio_bh_schedule_oneshot(qemu_get_aio_context(),

- job_defer_to_main_loop_bh, data);

-}

-

int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp), Error **errp)

{

Error *local_err = NULL;

2.17.1

From: John Snow <jsnow@redhat.com>

Rename opaque_job to job to be consistent with other job implementations.

Rename 'job', the BackupBlockJob object, to 's' to also be consistent.

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

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

Reviewed-by: Max Reitz <mreitz@redhat.com>

Message-id: 20180830015734.19765-8-jsnow@redhat.com

block/backup.c | 62 +++++++++++++++++++++++++-------------------------

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

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

--- a/block/backup.c

+++ b/block/backup.c

@@ -XXX,XX +XXX,XX @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)

bdrv_dirty_iter_free(dbi);

}

-static int coroutine_fn backup_run(Job *opaque_job, Error **errp)

+static int coroutine_fn backup_run(Job *job, Error **errp)

{

- BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);

- BlockDriverState *bs = blk_bs(job->common.blk);

+ BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);

+ BlockDriverState *bs = blk_bs(s->common.blk);

int64_t offset, nb_clusters;

int ret = 0;

- QLIST_INIT(&job->inflight_reqs);

- qemu_co_rwlock_init(&job->flush_rwlock);

+ QLIST_INIT(&s->inflight_reqs);

+ qemu_co_rwlock_init(&s->flush_rwlock);

- nb_clusters = DIV_ROUND_UP(job->len, job->cluster_size);

- job_progress_set_remaining(&job->common.job, job->len);

+ nb_clusters = DIV_ROUND_UP(s->len, s->cluster_size);

+ job_progress_set_remaining(job, s->len);

- job->copy_bitmap = hbitmap_alloc(nb_clusters, 0);

- if (job->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {

- backup_incremental_init_copy_bitmap(job);

+ s->copy_bitmap = hbitmap_alloc(nb_clusters, 0);

+ if (s->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {

+ backup_incremental_init_copy_bitmap(s);

} else {

- hbitmap_set(job->copy_bitmap, 0, nb_clusters);

+ hbitmap_set(s->copy_bitmap, 0, nb_clusters);

2.17.1

From: John Snow <jsnow@redhat.com>

Change the manual deferment to mirror_exit into the implicit

callback to job_exit and the mirror_exit callback.

This does change the order of some bdrv_unref calls and job_completed,

but thanks to the new context in which we call .exit, this is safe to

defer the possible flushing of any nodes to the job_finalize_single

cleanup stage.

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

Message-id: 20180830015734.19765-6-jsnow@redhat.com

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

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

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

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

--- a/block/mirror.c

+++ b/block/mirror.c

@@ -XXX,XX +XXX,XX @@ static void mirror_wait_for_all_io(MirrorBlockJob *s)

}

}

-typedef struct {

- int ret;

-} MirrorExitData;

-

-static void mirror_exit(Job *job, void *opaque)

+static void mirror_exit(Job *job)

{

MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);

BlockJob *bjob = &s->common;

- MirrorExitData *data = opaque;

MirrorBDSOpaque *bs_opaque = s->mirror_top_bs->opaque;

AioContext *replace_aio_context = NULL;

BlockDriverState *src = s->mirror_top_bs->backing->bs;

BlockDriverState *target_bs = blk_bs(s->target);

BlockDriverState *mirror_top_bs = s->mirror_top_bs;

Error *local_err = NULL;

+ int ret = job->ret;

bdrv_release_dirty_bitmap(src, s->dirty_bitmap);

- /* Make sure that the source BDS doesn't go away before we called

- * job_completed(). */

+ /* Make sure that the source BDS doesn't go away during bdrv_replace_node,

+ * before we can call bdrv_drained_end */

bdrv_ref(src);

bdrv_ref(mirror_top_bs);

bdrv_ref(target_bs);

@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)

bdrv_set_backing_hd(target_bs, backing, &local_err);

if (local_err) {

error_report_err(local_err);

- data->ret = -EPERM;

+ ret = -EPERM;

}

}

}

@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)

aio_context_acquire(replace_aio_context);

}

- if (s->should_complete && data->ret == 0) {

+ if (s->should_complete && ret == 0) {

BlockDriverState *to_replace = src;

if (s->to_replace) {

to_replace = s->to_replace;

@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)

bdrv_drained_end(target_bs);

if (local_err) {

error_report_err(local_err);

- data->ret = -EPERM;

+ ret = -EPERM;

}

}

if (s->to_replace) {

@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)

blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);

bs_opaque->job = NULL;

- job_completed(job, data->ret);

- g_free(data);

bdrv_drained_end(src);

bdrv_unref(mirror_top_bs);

bdrv_unref(src);

+ job->ret = ret;

}

static void mirror_throttle(MirrorBlockJob *s)

@@ -XXX,XX +XXX,XX @@ static int mirror_flush(MirrorBlockJob *s)

static int coroutine_fn mirror_run(Job *job, Error **errp)

{

MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);

- MirrorExitData *data;

BlockDriverState *bs = s->mirror_top_bs->backing->bs;

BlockDriverState *target_bs = blk_bs(s->target);

bool need_drain = true;

@@ -XXX,XX +XXX,XX @@ immediate_exit:

g_free(s->in_flight_bitmap);

bdrv_dirty_iter_free(s->dbi);

- data = g_malloc(sizeof(*data));

- data->ret = ret;

-

if (need_drain) {

bdrv_drained_begin(bs);

}

- job_defer_to_main_loop(&s->common.job, mirror_exit, data);

return ret;

}

@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver mirror_job_driver = {

.user_resume = block_job_user_resume,

.drain = block_job_drain,

.run = mirror_run,

+ .exit = mirror_exit,

.pause = mirror_pause,

.complete = mirror_complete,

},

@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_active_job_driver = {

.user_resume = block_job_user_resume,

.drain = block_job_drain,

.run = mirror_run,

+ .exit = mirror_exit,

.pause = mirror_pause,

.complete = mirror_complete,

},

2.17.1

From: John Snow <jsnow@redhat.com>

Change the manual deferment to commit_complete into the implicit

callback to job_exit, renaming commit_complete to commit_exit.

This conversion does change the timing of when job_completed is

called to after the bdrv_replace_node and bdrv_unref calls, which

could have implications for bjob->blk which will now be put down

after this cleanup.

Kevin highlights that we did not take any permissions for that backend

at job creation time, so it is safe to reorder these operations.

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

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

1 file changed, 5 insertions(+), 17 deletions(-)

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

--- a/block/commit.c

+++ b/block/commit.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base,

return 0;

}

-typedef struct {

- int ret;

-} CommitCompleteData;

-

-static void commit_complete(Job *job, void *opaque)

+static void commit_exit(Job *job)

{

CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);

BlockJob *bjob = &s->common;

- CommitCompleteData *data = opaque;

BlockDriverState *top = blk_bs(s->top);

BlockDriverState *base = blk_bs(s->base);

BlockDriverState *commit_top_bs = s->commit_top_bs;

- int ret = data->ret;

bool remove_commit_top_bs = false;

/* Make sure commit_top_bs and top stay around until bdrv_replace_node() */

@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)

* the normal backing chain can be restored. */

blk_unref(s->base);

- if (!job_is_cancelled(job) && ret == 0) {

+ if (!job_is_cancelled(job) && job->ret == 0) {

/* success */

- ret = bdrv_drop_intermediate(s->commit_top_bs, base,

- s->backing_file_str);

+ job->ret = bdrv_drop_intermediate(s->commit_top_bs, base,

+ s->backing_file_str);

} else {

/* XXX Can (or should) we somehow keep 'consistent read' blocked even

* after the failed/cancelled commit job is gone? If we already wrote

@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)

* bdrv_set_backing_hd() to fail. */

block_job_remove_all_bdrv(bjob);

- job_completed(job, ret);

- g_free(data);

-

/* If bdrv_drop_intermediate() didn't already do that, remove the commit

* filter driver from the backing chain. Do this as the final step so that

* the 'consistent read' permission can be granted. */

@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)

static int coroutine_fn commit_run(Job *job, Error **errp)

{

CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);

- CommitCompleteData *data;

int64_t offset;

uint64_t delay_ns = 0;

int ret = 0;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)

out:

qemu_vfree(buf);

- data = g_malloc(sizeof(*data));

- data->ret = ret;

- job_defer_to_main_loop(&s->common.job, commit_complete, data);

return ret;

}

@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_job_driver = {

.user_resume = block_job_user_resume,

.drain = block_job_drain,

.run = commit_run,

+ .exit = commit_exit,

},

};

2.17.1

From: John Snow <jsnow@redhat.com>

Jobs are now expected to return their retcode on the stack, from the

.run callback, so we can remove that argument.

job_cancel does not need to set -ECANCELED because job_completed will

update the return code itself if the job was canceled.

While we're here, make job_completed static to job.c and remove it from

job.h; move the documentation of return code to the .run() callback and

to the job->ret property, accordingly.

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

Message-id: 20180830015734.19765-9-jsnow@redhat.com

include/qemu/job.h | 28 +++++++++++++++-------------

job.c | 11 ++++++-----

trace-events | 2 +-

3 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/include/qemu/job.h b/include/qemu/job.h

--- a/include/qemu/job.h

+++ b/include/qemu/job.h

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

/** Estimated progress_current value at the completion of the job */

int64_t progress_total;

- /** ret code passed to job_completed. */

+ /**

+ * Return code from @run and/or @prepare callback(s).

+ * Not final until the job has reached the CONCLUDED status.

+ * 0 on success, -errno on failure.

+ */

int ret;

/**

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

/** Enum describing the operation */

JobType job_type;

- /** Mandatory: Entrypoint for the Coroutine. */

+ /**

+ * Mandatory: Entrypoint for the Coroutine.

+ *

+ * This callback will be invoked when moving from CREATED to RUNNING.

+ *

+ * If this callback returns nonzero, the job transaction it is part of is

+ * aborted. If it returns zero, the job moves into the WAITING state. If it

+ * is the last job to complete in its transaction, all jobs in the

+ * transaction move from WAITING to PENDING.

+ */

int coroutine_fn (*run)(Job *job, Error **errp);

/**

@@ -XXX,XX +XXX,XX @@ void job_early_fail(Job *job);

/** Moves the @job from RUNNING to READY */

void job_transition_to_ready(Job *job);

-/**

- * @job: The job being completed.

- * @ret: The status code.

- *

- * Marks @job as completed. If @ret is non-zero, the job transaction it is part

- * of is aborted. If @ret is zero, the job moves into the WAITING state. If it

- * is the last job to complete in its transaction, all jobs in the transaction

- * move from WAITING to PENDING.

- */

-void job_completed(Job *job, int ret);

-

/** Asynchronously complete the specified @job. */

void job_complete(Job *job, Error **errp);

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

--- a/job.c

+++ b/job.c

@@ -XXX,XX +XXX,XX @@ void job_drain(Job *job)

}

}

+static void job_completed(Job *job);

+

static void job_exit(void *opaque)

{

Job *job = (Job *)opaque;

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

job->driver->exit(job);

aio_context_release(aio_context);

}

- job_completed(job, job->ret);

+ job_completed(job);

}

/**

@@ -XXX,XX +XXX,XX @@ static void job_completed_txn_success(Job *job)

}

}

-void job_completed(Job *job, int ret)

+static void job_completed(Job *job)

{

assert(job && job->txn && !job_is_completed(job));

- job->ret = ret;

job_update_rc(job);

- trace_job_completed(job, ret, job->ret);

+ trace_job_completed(job, job->ret);

if (job->ret) {

job_completed_txn_abort(job);

} else {

@@ -XXX,XX +XXX,XX @@ void job_cancel(Job *job, bool force)

}

job_cancel_async(job, force);

if (!job_started(job)) {

- job_completed(job, -ECANCELED);

+ job_completed(job);

} else if (job->deferred_to_main_loop) {

job_completed_txn_abort(job);

} else {

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

index XXXXXXX..XXXXXXX 100644

--- a/trace-events

+++ b/trace-events

@@ -XXX,XX +XXX,XX @@ gdbstub_err_checksum_incorrect(uint8_t expected, uint8_t got) "got command packe

# job.c

job_state_transition(void *job, int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"

job_apply_verb(void *job, const char *state, const char *verb, const char *legal) "job %p in state %s; applying verb %s (%s)"

-job_completed(void *job, int ret, int jret) "job %p ret %d corrected ret %d"

+job_completed(void *job, int ret) "job %p ret %d"

# job-qmp.c

qmp_job_cancel(void *job) "job %p"

2.17.1

From: John Snow <jsnow@redhat.com>

Presently we codify the entry point for a job as the "start" callback,

but a more apt name would be "run" to clarify the idea that when this

function returns we consider the job to have "finished," except for

any cleanup which occurs in separate callbacks later.

As part of this clarification, change the signature to include an error

object and a return code. The error ptr is not yet used, and the return

code while captured, will be overwritten by actions in the job_completed

function.

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

Reviewed-by: Max Reitz <mreitz@redhat.com>

Message-id: 20180830015734.19765-2-jsnow@redhat.com

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

include/qemu/job.h | 2 +-

block/backup.c | 7 ++++---

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

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

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

block/stream.c | 7 ++++---

job.c | 6 +++---

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

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

tests/test-blockjob.c | 7 ++++---

10 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/include/qemu/job.h b/include/qemu/job.h

--- a/include/qemu/job.h

+++ b/include/qemu/job.h

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

JobType job_type;

/** Mandatory: Entrypoint for the Coroutine. */

- CoroutineEntry *start;

+ int coroutine_fn (*run)(Job *job, Error **errp);

/**

* If the callback is not NULL, it will be invoked when the job transitions

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 @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)

bdrv_dirty_iter_free(dbi);

}

-static void coroutine_fn backup_run(void *opaque)

+static int coroutine_fn backup_run(Job *opaque_job, Error **errp)

{

- BackupBlockJob *job = opaque;

+ BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);

BackupCompleteData *data;

BlockDriverState *bs = blk_bs(job->common.blk);

int64_t offset, nb_clusters;

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

data = g_malloc(sizeof(*data));

data->ret = ret;

job_defer_to_main_loop(&job->common.job, backup_complete, data);

+ return ret;

}

static const BlockJobDriver backup_job_driver = {

@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver backup_job_driver = {

.free = block_job_free,

.user_resume = block_job_user_resume,

.drain = block_job_drain,

- .start = backup_run,

+ .run = backup_run,

.commit = backup_commit,

.abort = backup_abort,

.clean = backup_clean,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/commit.c

+++ b/block/commit.c

@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)

bdrv_unref(top);

}

-static void coroutine_fn commit_run(void *opaque)

+static int coroutine_fn commit_run(Job *job, Error **errp)

{

- CommitBlockJob *s = opaque;

+ CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);

CommitCompleteData *data;

int64_t offset;

uint64_t delay_ns = 0;

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

data = g_malloc(sizeof(*data));

data->ret = ret;

job_defer_to_main_loop(&s->common.job, commit_complete, data);

+ return ret;

}

static const BlockJobDriver commit_job_driver = {

@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_job_driver = {

.free = block_job_free,

.user_resume = block_job_user_resume,

.drain = block_job_drain,

- .start = commit_run,

+ .run = commit_run,

},

};

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

index XXXXXXX..XXXXXXX 100644

--- a/block/create.c

+++ b/block/create.c

@@ -XXX,XX +XXX,XX @@ static void blockdev_create_complete(Job *job, void *opaque)

job_completed(job, s->ret, s->err);

}

-static void coroutine_fn blockdev_create_run(void *opaque)

+static int coroutine_fn blockdev_create_run(Job *job, Error **errp)

{

- BlockdevCreateJob *s = opaque;

+ BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);

job_progress_set_remaining(&s->common, 1);

s->ret = s->drv->bdrv_co_create(s->opts, &s->err);

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

qapi_free_BlockdevCreateOptions(s->opts);

job_defer_to_main_loop(&s->common, blockdev_create_complete, NULL);

+

+ return s->ret;

}

static const JobDriver blockdev_create_job_driver = {

.instance_size = sizeof(BlockdevCreateJob),

.job_type = JOB_TYPE_CREATE,

- .start = blockdev_create_run,

+ .run = blockdev_create_run,

};

void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/mirror.c

+++ b/block/mirror.c

@@ -XXX,XX +XXX,XX @@ static int mirror_flush(MirrorBlockJob *s)

-static void coroutine_fn mirror_run(void *opaque)

+static int coroutine_fn mirror_run(Job *job, Error **errp)