Commit 2869653f authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging 



Block layer patches

# gpg: Signature made Wed 11 Nov 2015 16:03:19 GMT using RSA key ID C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"

* remotes/kevin/tags/for-upstream: (41 commits)
  iotests: Check for quorum support in test 139
  qcow2: Fix qcow2_get_cluster_offset() for zero clusters
  iotests: Add tests for the x-blockdev-del command
  block: Add 'x-blockdev-del' QMP command
  block: Add blk_get_refcnt()
  mirror: block all operations on the target image during the job
  qemu-iotests: fix -valgrind option for check
  qemu-iotests: fix cleanup of background processes
  qemu-io: Correct error messages
  qemu-io: Check for trailing chars
  qemu-io: fix cvtnum lval types
  block: test 'blockdev-snapshot' using a file BDS as the overlay
  block: Remove inner quotation marks in iotest 085
  block: Disallow snapshots if the overlay doesn't support backing files
  throttle: Use bs->throttle_state instead of bs->io_limits_enabled
  throttle: Check for pending requests in throttle_group_unregister_bs()
  qemu-img: add check for zero-length job len
  qcow2: avoid misaligned 64bit bswap
  qemu-iotests: Test the reopening of overlay_bs in 'block-commit'
  commit: reopen overlay_bs before base
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 3c07587d 4d07c720

block.c

+14 −8
Original line number Diff line number Diff line
@@ -73,8 +73,7 @@ struct BdrvDirtyBitmap { 


#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */



static QTAILQ_HEAD(, BlockDriverState) bdrv_states =

    QTAILQ_HEAD_INITIALIZER(bdrv_states);

struct BdrvStates bdrv_states = QTAILQ_HEAD_INITIALIZER(bdrv_states);



static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =

    QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
@@ -1394,6 +1393,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 
    BlockDriverState *bs;

    BlockDriver *drv = NULL;

    const char *drvname;

    const char *backing;

    Error *local_err = NULL;

    int snapshot_flags = 0;
@@ -1461,6 +1461,12 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 


    assert(drvname || !(flags & BDRV_O_PROTOCOL));



    backing = qdict_get_try_str(options, "backing");

    if (backing && *backing == '\0') {

        flags |= BDRV_O_NO_BACKING;

        qdict_del(options, "backing");

    }



    bs->open_flags = flags;

    bs->options = options;

    options = qdict_clone_shallow(options);
@@ -1901,7 +1907,7 @@ void bdrv_close(BlockDriverState *bs) 
    }



    /* Disable I/O limits and drain all pending throttled requests */

    if (bs->io_limits_enabled) {

    if (bs->throttle_state) {

        bdrv_io_limits_disable(bs);

    }
@@ -2683,12 +2689,12 @@ BlockDriverState *bdrv_lookup_bs(const char *device, 
        blk = blk_by_name(device);



        if (blk) {

            if (!blk_bs(blk)) {

            bs = blk_bs(blk);

            if (!bs) {

                error_setg(errp, "Device '%s' has no medium", device);

                return NULL;

            }



            return blk_bs(blk);

            return bs;

        }

    }
@@ -3706,7 +3712,7 @@ void bdrv_detach_aio_context(BlockDriverState *bs) 
        baf->detach_aio_context(baf->opaque);

    }



    if (bs->io_limits_enabled) {

    if (bs->throttle_state) {

        throttle_timers_detach_aio_context(&bs->throttle_timers);

    }

    if (bs->drv->bdrv_detach_aio_context) {
@@ -3742,7 +3748,7 @@ void bdrv_attach_aio_context(BlockDriverState *bs, 
    if (bs->drv->bdrv_attach_aio_context) {

        bs->drv->bdrv_attach_aio_context(bs, new_context);

    }

    if (bs->io_limits_enabled) {

    if (bs->throttle_state) {

        throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);

    }

block/block-backend.c

+51 −10
Original line number Diff line number Diff line
@@ -189,6 +189,11 @@ static void drive_info_del(DriveInfo *dinfo) 
    g_free(dinfo);

}



int blk_get_refcnt(BlockBackend *blk)

{

    return blk ? blk->refcnt : 0;

}



/*

 * Increment @blk's reference count.

 * @blk must not be null.
@@ -333,6 +338,18 @@ void blk_hide_on_behalf_of_hmp_drive_del(BlockBackend *blk) 
    }

}



/*

 * Disassociates the currently associated BlockDriverState from @blk.

 */

void blk_remove_bs(BlockBackend *blk)

{

    blk_update_root_state(blk);



    blk->bs->blk = NULL;

    bdrv_unref(blk->bs);

    blk->bs = NULL;

}



/*

 * Associates a new BlockDriverState with @blk.

 */
@@ -417,18 +434,15 @@ void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, 
void blk_dev_change_media_cb(BlockBackend *blk, bool load)

{

    if (blk->dev_ops && blk->dev_ops->change_media_cb) {

        bool tray_was_closed = !blk_dev_is_tray_open(blk);

        bool tray_was_open, tray_is_open;



        tray_was_open = blk_dev_is_tray_open(blk);

        blk->dev_ops->change_media_cb(blk->dev_opaque, load);

        if (tray_was_closed) {

            /* tray open */

            qapi_event_send_device_tray_moved(blk_name(blk),

                                              true, &error_abort);

        }

        if (load) {

            /* tray close */

            qapi_event_send_device_tray_moved(blk_name(blk),

                                              false, &error_abort);

        tray_is_open = blk_dev_is_tray_open(blk);



        if (tray_was_open != tray_is_open) {

            qapi_event_send_device_tray_moved(blk_name(blk), tray_is_open,

                                              &error_abort);

        }

    }

}
@@ -1227,6 +1241,33 @@ void blk_update_root_state(BlockBackend *blk) 
    }

}



/*

 * Applies the information in the root state to the given BlockDriverState. This

 * does not include the flags which have to be specified for bdrv_open(), use

 * blk_get_open_flags_from_root_state() to inquire them.

 */

void blk_apply_root_state(BlockBackend *blk, BlockDriverState *bs)

{

    bs->detect_zeroes = blk->root_state.detect_zeroes;

    if (blk->root_state.throttle_group) {

        bdrv_io_limits_enable(bs, blk->root_state.throttle_group);

    }

}



/*

 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is

 * supposed to inherit the root state.

 */

int blk_get_open_flags_from_root_state(BlockBackend *blk)

{

    int bs_flags;



    bs_flags = blk->root_state.read_only ? 0 : BDRV_O_RDWR;

    bs_flags |= blk->root_state.open_flags & ~BDRV_O_RDWR;



    return bs_flags;

}



BlockBackendRootState *blk_get_root_state(BlockBackend *blk)

{

    return &blk->root_state;

block/commit.c

+4 −4
Original line number Diff line number Diff line
@@ -236,14 +236,14 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, 
    orig_overlay_flags = bdrv_get_flags(overlay_bs);



    /* convert base & overlay_bs to r/w, if necessary */

    if (!(orig_base_flags & BDRV_O_RDWR)) {

        reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,

                                         orig_base_flags | BDRV_O_RDWR);

    }

    if (!(orig_overlay_flags & BDRV_O_RDWR)) {

        reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs, NULL,

                                         orig_overlay_flags | BDRV_O_RDWR);

    }

    if (!(orig_base_flags & BDRV_O_RDWR)) {

        reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,

                                         orig_base_flags | BDRV_O_RDWR);

    }

    if (reopen_queue) {

        bdrv_reopen_multiple(reopen_queue, &local_err);

        if (local_err != NULL) {

block/mirror.c

+4 −0
Original line number Diff line number Diff line
@@ -384,6 +384,7 @@ static void mirror_exit(BlockJob *job, void *opaque) 
        aio_context_release(replace_aio_context);

    }

    g_free(s->replaces);

    bdrv_op_unblock_all(s->target, s->common.blocker);

    bdrv_unref(s->target);

    block_job_completed(&s->common, data->ret);

    g_free(data);
@@ -744,6 +745,9 @@ static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target, 
        block_job_release(bs);

        return;

    }



    bdrv_op_block_all(s->target, s->common.blocker);



    bdrv_set_enable_write_cache(s->target, true);

    if (s->target->blk) {

        blk_set_on_error(s->target->blk, on_target_error, on_target_error);

block/qapi.c

+1 −1
Original line number Diff line number Diff line
@@ -64,7 +64,7 @@ BlockDeviceInfo *bdrv_block_device_info(BlockDriverState *bs, Error **errp) 
    info->backing_file_depth = bdrv_get_backing_file_depth(bs);

    info->detect_zeroes = bs->detect_zeroes;



    if (bs->io_limits_enabled) {

    if (bs->throttle_state) {

        ThrottleConfig cfg;



        throttle_group_get_config(bs, &cfg);