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 patches:

- (Block) job exit refactoring, part 1

(removing job_defer_to_main_loop())

- test-bdrv-drain leak fix

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>

Utilize the job_exit shim by not calling job_defer_to_main_loop, and

where applicable, converting the deferred callback into the job_exit

callback.

This converts backup, stream, create, and the unit tests all at once.

Most of these jobs do not see any changes to the order in which they

clean up their resources, except the test-blockjob-txn test, which

now puts down its bs before job_completed is called.

This is safe for the same reason the reordering in the mirror job is

safe, because job_completed no longer runs under two locks, making

the unref safe even if it causes a flush.

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

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

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

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

block/backup.c | 16 ----------------

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

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

tests/test-bdrv-drain.c | 6 ------

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

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

6 files changed, 16 insertions(+), 63 deletions(-)

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

--- a/block/backup.c

+++ b/block/backup.c

@@ -XXX,XX +XXX,XX @@ static BlockErrorAction backup_error_action(BackupBlockJob *job,

}

-typedef struct {

- int ret;

-} BackupCompleteData;

-

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

-{

- BackupCompleteData *data = opaque;

-

- job_completed(job, data->ret);

- g_free(data);

-}

-

static bool coroutine_fn yield_and_check(BackupBlockJob *job)

{

uint64_t delay_ns;

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

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

{

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

- BackupCompleteData *data;

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

int64_t offset, nb_clusters;

int ret = 0;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *opaque_job, Error **errp)

qemu_co_rwlock_unlock(&job->flush_rwlock);

hbitmap_free(job->copy_bitmap);

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

- data->ret = ret;

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

return ret;

}

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 @@ typedef struct BlockdevCreateJob {

Job common;

BlockDriver *drv;

BlockdevCreateOptions *opts;

- int ret;

} BlockdevCreateJob;

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

-{

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

-

- job_completed(job, s->ret);

-}

-

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

{

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

+ int ret;

job_progress_set_remaining(&s->common, 1);

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

+ ret = s->drv->bdrv_co_create(s->opts, errp);

job_progress_update(&s->common, 1);

qapi_free_BlockdevCreateOptions(s->opts);

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

- return s->ret;

+ return ret;

}

static const JobDriver blockdev_create_job_driver = {

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

index XXXXXXX..XXXXXXX 100644

--- a/block/stream.c

+++ b/block/stream.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_populate(BlockBackend *blk,

return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);

}

-typedef struct {

- int ret;

-} StreamCompleteData;

-

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

+static void stream_exit(Job *job)

{

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

BlockJob *bjob = &s->common;

- StreamCompleteData *data = opaque;

BlockDriverState *bs = blk_bs(bjob->blk);

BlockDriverState *base = s->base;

Error *local_err = NULL;

+ int ret = job->ret;

- if (!job_is_cancelled(job) && bs->backing && data->ret == 0) {

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

const char *base_id = NULL, *base_fmt = NULL;

if (base) {

base_id = s->backing_file_str;

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

base_fmt = base->drv->format_name;

- data->ret = bdrv_change_backing_file(bs, base_id, base_fmt);

+ ret = bdrv_change_backing_file(bs, base_id, base_fmt);

bdrv_set_backing_hd(bs, base, &local_err);

if (local_err) {

error_report_err(local_err);

- data->ret = -EPERM;

+ ret = -EPERM;

goto out;

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

}

g_free(s->backing_file_str);

- job_completed(job, data->ret);

- g_free(data);

+ job->ret = ret;

}

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

{

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

- StreamCompleteData *data;

BlockBackend *blk = s->common.blk;

BlockDriverState *bs = blk_bs(blk);

BlockDriverState *base = s->base;

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

out:

/* Modify backing chain and close BDSes in main loop */

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

- data->ret = ret;

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

return ret;

}

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

.job_type = JOB_TYPE_STREAM,

.free = block_job_free,

.run = stream_run,

+ .exit = stream_exit,

.user_resume = block_job_user_resume,

.drain = block_job_drain,

},

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 @@ typedef struct TestBlockJob {

bool should_complete;

} TestBlockJob;

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

-{

- job_completed(job, 0);

-}

-

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

{

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

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

job_pause_point(&s->common.job);

}

- job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);

return 0;

}

diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c

index XXXXXXX..XXXXXXX 100644

--- a/tests/test-blockjob-txn.c

+++ b/tests/test-blockjob-txn.c

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

int *result;

} TestBlockJob;

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

+static void test_block_job_exit(Job *job)

{

BlockJob *bjob = container_of(job, BlockJob, job);

BlockDriverState *bs = blk_bs(bjob->blk);

- int rc = (intptr_t)opaque;

- if (job_is_cancelled(job)) {

- rc = -ECANCELED;

- }

-

- job_completed(job, rc);

bdrv_unref(bs);

}

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

- job_defer_to_main_loop(job, test_block_job_complete,

- (void *)(intptr_t)s->rc);

return s->rc;

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

.user_resume = block_job_user_resume,

.drain = block_job_drain,

.run = test_block_job_run,

+ .exit = test_block_job_exit,

},

};

diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c

index XXXXXXX..XXXXXXX 100644

--- a/tests/test-blockjob.c

+++ b/tests/test-blockjob.c

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

bool completed;

} CancelJob;

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

+static void cancel_job_exit(Job *job)

- CancelJob *s = opaque;

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

s->completed = true;

- job_completed(job, 0);

static void cancel_job_complete(Job *job, Error **errp)

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

while (!s->should_complete) {

if (job_is_cancelled(&s->common.job)) {

- goto defer;

+ return 0;

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

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

Signed-off-by: Max Reitz <mreitz@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.

+ */

/**

@@ -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

index XXXXXXX..XXXXXXX 100644

--- 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>

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>

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

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

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

Signed-off-by: Max Reitz <mreitz@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;