Commit 8254b6d9 authored by John Snow's avatar John Snow Committed by Jeff Cody
Browse files

blockjob: centralize QMP event emissions 



There's no reason to leave this to blockdev; we can do it in blockjobs
directly and get rid of an extra callback for most users.

All non-internal events, even those created outside of QMP, will
consistently emit events.

Signed-off-by: default avatarJohn Snow <jsnow@redhat.com>
Reviewed-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarJeff Cody <jcody@redhat.com>
Message-id: 1477584421-1399-5-git-send-email-jsnow@redhat.com
Signed-off-by: default avatarJeff Cody <jcody@redhat.com>
parent 47970dfb

block/commit.c

+4 −4
Original line number Diff line number Diff line
@@ -209,8 +209,8 @@ static const BlockJobDriver commit_job_driver = { 


void commit_start(const char *job_id, BlockDriverState *bs,

                  BlockDriverState *base, BlockDriverState *top, int64_t speed,

                  BlockdevOnError on_error, BlockCompletionFunc *cb,

                  void *opaque, const char *backing_file_str, Error **errp)

                  BlockdevOnError on_error, const char *backing_file_str,

                  Error **errp)

{

    CommitBlockJob *s;

    BlockReopenQueue *reopen_queue = NULL;
@@ -234,7 +234,7 @@ void commit_start(const char *job_id, BlockDriverState *bs, 
    }



    s = block_job_create(job_id, &commit_job_driver, bs, speed,

                         BLOCK_JOB_DEFAULT, cb, opaque, errp);

                         BLOCK_JOB_DEFAULT, NULL, NULL, errp);

    if (!s) {

        return;

    }
@@ -290,7 +290,7 @@ void commit_start(const char *job_id, BlockDriverState *bs, 
    s->on_error = on_error;

    s->common.co = qemu_coroutine_create(commit_run, s);



    trace_commit_start(bs, base, top, s, s->common.co, opaque);

    trace_commit_start(bs, base, top, s, s->common.co);

    qemu_coroutine_enter(s->common.co);

}

block/mirror.c

+2 −4
Original line number Diff line number Diff line
@@ -1018,9 +1018,7 @@ void mirror_start(const char *job_id, BlockDriverState *bs, 
                  MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,

                  BlockdevOnError on_source_error,

                  BlockdevOnError on_target_error,

                  bool unmap,

                  BlockCompletionFunc *cb,

                  void *opaque, Error **errp)

                  bool unmap, Error **errp)

{

    bool is_none_mode;

    BlockDriverState *base;
@@ -1033,7 +1031,7 @@ void mirror_start(const char *job_id, BlockDriverState *bs, 
    base = mode == MIRROR_SYNC_MODE_TOP ? backing_bs(bs) : NULL;

    mirror_start_job(job_id, bs, BLOCK_JOB_DEFAULT, target, replaces,

                     speed, granularity, buf_size, backing_mode,

                     on_source_error, on_target_error, unmap, cb, opaque, errp,

                     on_source_error, on_target_error, unmap, NULL, NULL, errp,

                     &mirror_job_driver, is_none_mode, base, false);

}

block/stream.c

+3 −4
Original line number Diff line number Diff line
@@ -222,15 +222,14 @@ static const BlockJobDriver stream_job_driver = { 


void stream_start(const char *job_id, BlockDriverState *bs,

                  BlockDriverState *base, const char *backing_file_str,

                  int64_t speed, BlockdevOnError on_error,

                  BlockCompletionFunc *cb, void *opaque, Error **errp)

                  int64_t speed, BlockdevOnError on_error, Error **errp)

{

    StreamBlockJob *s;

    BlockDriverState *iter;

    int orig_bs_flags;



    s = block_job_create(job_id, &stream_job_driver, bs, speed,

                         BLOCK_JOB_DEFAULT, cb, opaque, errp);

                         BLOCK_JOB_DEFAULT, NULL, NULL, errp);

    if (!s) {

        return;

    }
@@ -256,6 +255,6 @@ void stream_start(const char *job_id, BlockDriverState *bs, 


    s->on_error = on_error;

    s->common.co = qemu_coroutine_create(stream_run, s);

    trace_stream_start(bs, base, s, s->common.co, opaque);

    trace_stream_start(bs, base, s, s->common.co);

    qemu_coroutine_enter(s->common.co);

}

block/trace-events

+2 −3
Original line number Diff line number Diff line
@@ -19,11 +19,11 @@ bdrv_co_do_copy_on_readv(void *bs, int64_t offset, unsigned int bytes, int64_t c 


# block/stream.c

stream_one_iteration(void *s, int64_t sector_num, int nb_sectors, int is_allocated) "s %p sector_num %"PRId64" nb_sectors %d is_allocated %d"

stream_start(void *bs, void *base, void *s, void *co, void *opaque) "bs %p base %p s %p co %p opaque %p"

stream_start(void *bs, void *base, void *s, void *co) "bs %p base %p s %p co %p"



# block/commit.c

commit_one_iteration(void *s, int64_t sector_num, int nb_sectors, int is_allocated) "s %p sector_num %"PRId64" nb_sectors %d is_allocated %d"

commit_start(void *bs, void *base, void *top, void *s, void *co, void *opaque) "bs %p base %p top %p s %p co %p opaque %p"

commit_start(void *bs, void *base, void *top, void *s, void *co) "bs %p base %p top %p s %p co %p"



# block/mirror.c

mirror_start(void *bs, void *s, void *co, void *opaque) "bs %p s %p co %p opaque %p"
@@ -51,7 +51,6 @@ qmp_block_job_cancel(void *job) "job %p" 
qmp_block_job_pause(void *job) "job %p"

qmp_block_job_resume(void *job) "job %p"

qmp_block_job_complete(void *job) "job %p"

block_job_cb(void *bs, void *job, int ret) "bs %p job %p ret %d"

qmp_block_stream(void *bs, void *job) "bs %p job %p"



# block/raw-win32.c

blockdev.c

+8 −34
Original line number Diff line number Diff line
@@ -2905,31 +2905,6 @@ out: 
    aio_context_release(aio_context);

}



static void block_job_cb(void *opaque, int ret)

{

    /* Note that this function may be executed from another AioContext besides

     * the QEMU main loop.  If you need to access anything that assumes the

     * QEMU global mutex, use a BH or introduce a mutex.

     */



    BlockDriverState *bs = opaque;

    const char *msg = NULL;



    trace_block_job_cb(bs, bs->job, ret);



    assert(bs->job);



    if (ret < 0) {

        msg = strerror(-ret);

    }



    if (block_job_is_cancelled(bs->job)) {

        block_job_event_cancelled(bs->job);

    } else {

        block_job_event_completed(bs->job, msg);

    }

}



void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,

                      bool has_base, const char *base,

                      bool has_base_node, const char *base_node,
@@ -3005,7 +2980,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device, 
    base_name = has_backing_file ? backing_file : base_name;



    stream_start(has_job_id ? job_id : NULL, bs, base_bs, base_name,

                 has_speed ? speed : 0, on_error, block_job_cb, bs, &local_err);

                 has_speed ? speed : 0, on_error, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

        goto out;
@@ -3111,16 +3086,16 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device, 
            goto out;

        }

        commit_active_start(has_job_id ? job_id : NULL, bs, base_bs,

                            BLOCK_JOB_DEFAULT, speed, on_error, block_job_cb,

                            bs, &local_err, false);

                            BLOCK_JOB_DEFAULT, speed, on_error, NULL, NULL,

                            &local_err, false);

    } else {

        BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);

        if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {

            goto out;

        }

        commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, speed,

                     on_error, block_job_cb, bs,

                     has_backing_file ? backing_file : NULL, &local_err);

                     on_error, has_backing_file ? backing_file : NULL,

                     &local_err);

    }

    if (local_err != NULL) {

        error_propagate(errp, local_err);
@@ -3241,7 +3216,7 @@ static void do_drive_backup(DriveBackup *backup, BlockJobTxn *txn, Error **errp) 
    backup_start(backup->job_id, bs, target_bs, backup->speed, backup->sync,

                 bmap, backup->compress, backup->on_source_error,

                 backup->on_target_error, BLOCK_JOB_DEFAULT,

                 block_job_cb, bs, txn, &local_err);

                 NULL, NULL, txn, &local_err);

    bdrv_unref(target_bs);

    if (local_err != NULL) {

        error_propagate(errp, local_err);
@@ -3312,7 +3287,7 @@ void do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn, Error **errp) 
    backup_start(backup->job_id, bs, target_bs, backup->speed, backup->sync,

                 NULL, backup->compress, backup->on_source_error,

                 backup->on_target_error, BLOCK_JOB_DEFAULT,

                 block_job_cb, bs, txn, &local_err);

                 NULL, NULL, txn, &local_err);

    if (local_err != NULL) {

        error_propagate(errp, local_err);

    }
@@ -3391,8 +3366,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs, 
    mirror_start(job_id, bs, target,

                 has_replaces ? replaces : NULL,

                 speed, granularity, buf_size, sync, backing_mode,

                 on_source_error, on_target_error, unmap,

                 block_job_cb, bs, errp);

                 on_source_error, on_target_error, unmap, errp);

}



void qmp_drive_mirror(DriveMirror *arg, Error **errp)