Commit 8ee5f9b3 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 06 Sep 2017 14:44:41 BST
# gpg:                using RSA key 0x7F09B272C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"
# Primary key fingerprint: DC3D EB15 9A9A F95D 3D74  56FE 7F09 B272 C88F 2FD6

* remotes/kevin/tags/for-upstream:
  qcow2: move qcow2_store_persistent_dirty_bitmaps() before cache flushing
  qemu-iotests: add 184 for throttle filter driver
  block: add throttle block filter driver
  block: convert ThrottleGroup to object with QOM
  block: tidy ThrottleGroupMember initializations
  block: add aio_context field in ThrottleGroupMember
  block: move ThrottleGroup membership to ThrottleGroupMember
  block: document semantics of bdrv_co_preadv|pwritev
  qcow: Check failure of bdrv_getlength() and bdrv_truncate()
  qcow: Change signature of get_cluster_offset()
  block: add default implementations for bdrv_co_get_block_status()
  block: remove bdrv_truncate callback in blkdebug
  block: remove unused bdrv_media_changed
  block: pass bdrv_* methods to bs->file by default in block filters

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 8c6a76cd 83a8c775

block.c

+19 −16
Original line number Diff line number Diff line
@@ -496,6 +496,8 @@ int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) 


    if (drv && drv->bdrv_probe_blocksizes) {

        return drv->bdrv_probe_blocksizes(bs, bsz);

    } else if (drv && drv->is_filter && bs->file) {

        return bdrv_probe_blocksizes(bs->file->bs, bsz);

    }



    return -ENOTSUP;
@@ -513,6 +515,8 @@ int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo) 


    if (drv && drv->bdrv_probe_geometry) {

        return drv->bdrv_probe_geometry(bs, geo);

    } else if (drv && drv->is_filter && bs->file) {

        return bdrv_probe_geometry(bs->file->bs, geo);

    }



    return -ENOTSUP;
@@ -3426,11 +3430,15 @@ int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc, 


    assert(child->perm & BLK_PERM_RESIZE);



    /* if bs->drv == NULL, bs is closed, so there's nothing to do here */

    if (!drv) {

        error_setg(errp, "No medium inserted");

        return -ENOMEDIUM;

    }

    if (!drv->bdrv_truncate) {

        if (bs->file && drv->is_filter) {

            return bdrv_truncate(bs->file, offset, prealloc, errp);

        }

        error_setg(errp, "Image format driver does not support resize");

        return -ENOTSUP;

    }
@@ -3767,6 +3775,9 @@ int bdrv_has_zero_init(BlockDriverState *bs) 
    if (bs->drv->bdrv_has_zero_init) {

        return bs->drv->bdrv_has_zero_init(bs);

    }

    if (bs->file && bs->drv->is_filter) {

        return bdrv_has_zero_init(bs->file->bs);

    }



    /* safe default */

    return 0;
@@ -3821,10 +3832,16 @@ void bdrv_get_backing_filename(BlockDriverState *bs, 
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)

{

    BlockDriver *drv = bs->drv;

    if (!drv)

    /* if bs->drv == NULL, bs is closed, so there's nothing to do here */

    if (!drv) {

        return -ENOMEDIUM;

    if (!drv->bdrv_get_info)

    }

    if (!drv->bdrv_get_info) {

        if (bs->file && drv->is_filter) {

            return bdrv_get_info(bs->file->bs, bdi);

        }

        return -ENOTSUP;

    }

    memset(bdi, 0, sizeof(*bdi));

    return drv->bdrv_get_info(bs, bdi);

}
@@ -4174,20 +4191,6 @@ bool bdrv_is_inserted(BlockDriverState *bs) 
    return true;

}



/**

 * Return whether the media changed since the last call to this

 * function, or -ENOTSUP if we don't know.  Most drivers don't know.

 */

int bdrv_media_changed(BlockDriverState *bs)

{

    BlockDriver *drv = bs->drv;



    if (drv && drv->bdrv_media_changed) {

        return drv->bdrv_media_changed(bs);

    }

    return -ENOTSUP;

}



/**

 * If eject_flag is TRUE, eject the media. Otherwise, close the tray

 */

block/Makefile.objs

+1 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ block-obj-y += accounting.o dirty-bitmap.o 
block-obj-y += write-threshold.o

block-obj-y += backup.o

block-obj-$(CONFIG_REPLICATION) += replication.o

block-obj-y += throttle.o



block-obj-y += crypto.o

block/blkdebug.c

+2 −18
Original line number Diff line number Diff line
@@ -628,16 +628,6 @@ static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs, 
    return bdrv_co_pdiscard(bs->file->bs, offset, bytes);

}



static int64_t coroutine_fn blkdebug_co_get_block_status(

    BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum,

    BlockDriverState **file)

{

    *pnum = nb_sectors;

    *file = bs->file->bs;

    return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID |

        (sector_num << BDRV_SECTOR_BITS);

}



static void blkdebug_close(BlockDriverState *bs)

{

    BDRVBlkdebugState *s = bs->opaque;
@@ -808,12 +798,6 @@ static int64_t blkdebug_getlength(BlockDriverState *bs) 
    return bdrv_getlength(bs->file->bs);

}



static int blkdebug_truncate(BlockDriverState *bs, int64_t offset,

                             PreallocMode prealloc, Error **errp)

{

    return bdrv_truncate(bs->file, offset, prealloc, errp);

}



static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)

{

    BDRVBlkdebugState *s = bs->opaque;
@@ -896,6 +880,7 @@ static BlockDriver bdrv_blkdebug = { 
    .format_name            = "blkdebug",

    .protocol_name          = "blkdebug",

    .instance_size          = sizeof(BDRVBlkdebugState),

    .is_filter              = true,



    .bdrv_parse_filename    = blkdebug_parse_filename,

    .bdrv_file_open         = blkdebug_open,
@@ -904,7 +889,6 @@ static BlockDriver bdrv_blkdebug = { 
    .bdrv_child_perm        = bdrv_filter_default_perms,



    .bdrv_getlength         = blkdebug_getlength,

    .bdrv_truncate          = blkdebug_truncate,

    .bdrv_refresh_filename  = blkdebug_refresh_filename,

    .bdrv_refresh_limits    = blkdebug_refresh_limits,
@@ -913,7 +897,7 @@ static BlockDriver bdrv_blkdebug = { 
    .bdrv_co_flush_to_disk  = blkdebug_co_flush,

    .bdrv_co_pwrite_zeroes  = blkdebug_co_pwrite_zeroes,

    .bdrv_co_pdiscard       = blkdebug_co_pdiscard,

    .bdrv_co_get_block_status = blkdebug_co_get_block_status,

    .bdrv_co_get_block_status = bdrv_co_get_block_status_from_file,



    .bdrv_debug_event           = blkdebug_debug_event,

    .bdrv_debug_breakpoint      = blkdebug_debug_breakpoint,

block/block-backend.c

+32 −30
Original line number Diff line number Diff line
@@ -273,9 +273,6 @@ BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm) 
    blk->shared_perm = shared_perm;

    blk_set_enable_write_cache(blk, true);



    qemu_co_mutex_init(&blk->public.throttled_reqs_lock);

    qemu_co_queue_init(&blk->public.throttled_reqs[0]);

    qemu_co_queue_init(&blk->public.throttled_reqs[1]);

    block_acct_init(&blk->stats);



    notifier_list_init(&blk->remove_bs_notifiers);
@@ -343,7 +340,7 @@ static void blk_delete(BlockBackend *blk) 
    assert(!blk->refcnt);

    assert(!blk->name);

    assert(!blk->dev);

    if (blk->public.throttle_state) {

    if (blk->public.throttle_group_member.throttle_state) {

        blk_io_limits_disable(blk);

    }

    if (blk->root) {
@@ -658,9 +655,12 @@ BlockBackend *blk_by_public(BlockBackendPublic *public) 
 */

void blk_remove_bs(BlockBackend *blk)

{

    ThrottleTimers *tt;



    notifier_list_notify(&blk->remove_bs_notifiers, blk);

    if (blk->public.throttle_state) {

        throttle_timers_detach_aio_context(&blk->public.throttle_timers);

    if (blk->public.throttle_group_member.throttle_state) {

        tt = &blk->public.throttle_group_member.throttle_timers;

        throttle_timers_detach_aio_context(tt);

    }



    blk_update_root_state(blk);
@@ -682,9 +682,10 @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp) 
    bdrv_ref(bs);



    notifier_list_notify(&blk->insert_bs_notifiers, blk);

    if (blk->public.throttle_state) {

    if (blk->public.throttle_group_member.throttle_state) {

        throttle_timers_attach_aio_context(

            &blk->public.throttle_timers, bdrv_get_aio_context(bs));

            &blk->public.throttle_group_member.throttle_timers,

            bdrv_get_aio_context(bs));

    }



    return 0;
@@ -1046,8 +1047,9 @@ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset, 
    bdrv_inc_in_flight(bs);



    /* throttling disk I/O */

    if (blk->public.throttle_state) {

        throttle_group_co_io_limits_intercept(blk, bytes, false);

    if (blk->public.throttle_group_member.throttle_state) {

        throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,

                bytes, false);

    }



    ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags);
@@ -1070,10 +1072,10 @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset, 
    }



    bdrv_inc_in_flight(bs);



    /* throttling disk I/O */

    if (blk->public.throttle_state) {

        throttle_group_co_io_limits_intercept(blk, bytes, true);

    if (blk->public.throttle_group_member.throttle_state) {

        throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,

                bytes, true);

    }



    if (!blk->enable_write_cache) {
@@ -1742,16 +1744,14 @@ static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb) 
void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)

{

    BlockDriverState *bs = blk_bs(blk);

    ThrottleGroupMember *tgm = &blk->public.throttle_group_member;



    if (bs) {

        if (blk->public.throttle_state) {

            throttle_timers_detach_aio_context(&blk->public.throttle_timers);

        if (tgm->throttle_state) {

            throttle_group_detach_aio_context(tgm);

            throttle_group_attach_aio_context(tgm, new_context);

        }

        bdrv_set_aio_context(bs, new_context);

        if (blk->public.throttle_state) {

            throttle_timers_attach_aio_context(&blk->public.throttle_timers,

                                               new_context);

        }

    }

}
@@ -1969,33 +1969,35 @@ int blk_commit_all(void) 
/* throttling disk I/O limits */

void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)

{

    throttle_group_config(blk, cfg);

    throttle_group_config(&blk->public.throttle_group_member, cfg);

}



void blk_io_limits_disable(BlockBackend *blk)

{

    assert(blk->public.throttle_state);

    assert(blk->public.throttle_group_member.throttle_state);

    bdrv_drained_begin(blk_bs(blk));

    throttle_group_unregister_blk(blk);

    throttle_group_unregister_tgm(&blk->public.throttle_group_member);

    bdrv_drained_end(blk_bs(blk));

}



/* should be called before blk_set_io_limits if a limit is set */

void blk_io_limits_enable(BlockBackend *blk, const char *group)

{

    assert(!blk->public.throttle_state);

    throttle_group_register_blk(blk, group);

    assert(!blk->public.throttle_group_member.throttle_state);

    throttle_group_register_tgm(&blk->public.throttle_group_member,

                                group, blk_get_aio_context(blk));

}



void blk_io_limits_update_group(BlockBackend *blk, const char *group)

{

    /* this BB is not part of any group */

    if (!blk->public.throttle_state) {

    if (!blk->public.throttle_group_member.throttle_state) {

        return;

    }



    /* this BB is a part of the same group than the one we want */

    if (!g_strcmp0(throttle_group_get_name(blk), group)) {

    if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),

                group)) {

        return;

    }
@@ -2017,8 +2019,8 @@ static void blk_root_drained_begin(BdrvChild *child) 
    /* Note that blk->root may not be accessible here yet if we are just

     * attaching to a BlockDriverState that is drained. Use child instead. */



    if (atomic_fetch_inc(&blk->public.io_limits_disabled) == 0) {

        throttle_group_restart_blk(blk);

    if (atomic_fetch_inc(&blk->public.throttle_group_member.io_limits_disabled) == 0) {

        throttle_group_restart_tgm(&blk->public.throttle_group_member);

    }

}
@@ -2027,8 +2029,8 @@ static void blk_root_drained_end(BdrvChild *child) 
    BlockBackend *blk = child->opaque;

    assert(blk->quiesce_counter);



    assert(blk->public.io_limits_disabled);

    atomic_dec(&blk->public.io_limits_disabled);

    assert(blk->public.throttle_group_member.io_limits_disabled);

    atomic_dec(&blk->public.throttle_group_member.io_limits_disabled);



    if (--blk->quiesce_counter == 0) {

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

block/commit.c

+1 −11
Original line number Diff line number Diff line
@@ -244,16 +244,6 @@ static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs, 
    return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);

}



static int64_t coroutine_fn bdrv_commit_top_get_block_status(

    BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum,

    BlockDriverState **file)

{

    *pnum = nb_sectors;

    *file = bs->backing->bs;

    return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID |

           (sector_num << BDRV_SECTOR_BITS);

}



static void bdrv_commit_top_refresh_filename(BlockDriverState *bs, QDict *opts)

{

    bdrv_refresh_filename(bs->backing->bs);
@@ -279,7 +269,7 @@ static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c, 
static BlockDriver bdrv_commit_top = {

    .format_name                = "commit_top",

    .bdrv_co_preadv             = bdrv_commit_top_preadv,

    .bdrv_co_get_block_status   = bdrv_commit_top_get_block_status,

    .bdrv_co_get_block_status   = bdrv_co_get_block_status_from_backing,

    .bdrv_refresh_filename      = bdrv_commit_top_refresh_filename,

    .bdrv_close                 = bdrv_commit_top_close,

    .bdrv_child_perm            = bdrv_commit_top_child_perm,