Commit 20dca810 authored by John Snow's avatar John Snow Committed by Kevin Wolf
Browse files

block: Ensure consistent bitmap function prototypes 



We often don't need the BlockDriverState for functions
that operate on bitmaps. Remove it.

Signed-off-by: default avatarJohn Snow <jsnow@redhat.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
Reviewed-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Message-id: 1429314609-29776-15-git-send-email-jsnow@redhat.com
Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent aa0c7ca5

block.c

+6 −7
Original line number Diff line number Diff line
@@ -5526,7 +5526,7 @@ BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name) 
    return NULL;

}



void bdrv_dirty_bitmap_make_anon(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)

void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)

{

    assert(!bdrv_dirty_bitmap_frozen(bitmap));

    g_free(bitmap->name);
@@ -5695,7 +5695,7 @@ BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs) 
    QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {

        BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);

        BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);

        info->count = bdrv_get_dirty_count(bs, bm);

        info->count = bdrv_get_dirty_count(bm);

        info->granularity = bdrv_dirty_bitmap_granularity(bm);

        info->has_name = !!bm->name;

        info->name = g_strdup(bm->name);
@@ -5742,20 +5742,19 @@ uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap) 
    return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);

}



void bdrv_dirty_iter_init(BlockDriverState *bs,

                          BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)

void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)

{

    hbitmap_iter_init(hbi, bitmap->bitmap, 0);

}



void bdrv_set_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,

void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,

                           int64_t cur_sector, int nr_sectors)

{

    assert(bdrv_dirty_bitmap_enabled(bitmap));

    hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);

}



void bdrv_reset_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,

void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,

                             int64_t cur_sector, int nr_sectors)

{

    assert(bdrv_dirty_bitmap_enabled(bitmap));
@@ -5801,7 +5800,7 @@ void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset) 
    hbitmap_iter_init(hbi, hbi->hb, offset);

}



int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)

int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)

{

    return hbitmap_count(bitmap->bitmap);

}

block/backup.c

+1 −1
Original line number Diff line number Diff line
@@ -284,7 +284,7 @@ static int coroutine_fn backup_run_incremental(BackupBlockJob *job) 


    granularity = bdrv_dirty_bitmap_granularity(job->sync_bitmap);

    clusters_per_iter = MAX((granularity / BACKUP_CLUSTER_SIZE), 1);

    bdrv_dirty_iter_init(bs, job->sync_bitmap, &hbi);

    bdrv_dirty_iter_init(job->sync_bitmap, &hbi);



    /* Find the next dirty sector(s) */

    while ((sector = hbitmap_iter_next(&hbi)) != -1) {

block/mirror.c

+10 −16
Original line number Diff line number Diff line
@@ -125,11 +125,9 @@ static void mirror_write_complete(void *opaque, int ret) 
    MirrorOp *op = opaque;

    MirrorBlockJob *s = op->s;

    if (ret < 0) {

        BlockDriverState *source = s->common.bs;

        BlockErrorAction action;



        bdrv_set_dirty_bitmap(source, s->dirty_bitmap, op->sector_num,

                              op->nb_sectors);

        bdrv_set_dirty_bitmap(s->dirty_bitmap, op->sector_num, op->nb_sectors);

        action = mirror_error_action(s, false, -ret);

        if (action == BLOCK_ERROR_ACTION_REPORT && s->ret >= 0) {

            s->ret = ret;
@@ -143,11 +141,9 @@ static void mirror_read_complete(void *opaque, int ret) 
    MirrorOp *op = opaque;

    MirrorBlockJob *s = op->s;

    if (ret < 0) {

        BlockDriverState *source = s->common.bs;

        BlockErrorAction action;



        bdrv_set_dirty_bitmap(source, s->dirty_bitmap, op->sector_num,

                              op->nb_sectors);

        bdrv_set_dirty_bitmap(s->dirty_bitmap, op->sector_num, op->nb_sectors);

        action = mirror_error_action(s, true, -ret);

        if (action == BLOCK_ERROR_ACTION_REPORT && s->ret >= 0) {

            s->ret = ret;
@@ -170,10 +166,9 @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s) 


    s->sector_num = hbitmap_iter_next(&s->hbi);

    if (s->sector_num < 0) {

        bdrv_dirty_iter_init(source, s->dirty_bitmap, &s->hbi);

        bdrv_dirty_iter_init(s->dirty_bitmap, &s->hbi);

        s->sector_num = hbitmap_iter_next(&s->hbi);

        trace_mirror_restart_iter(s,

                                  bdrv_get_dirty_count(source, s->dirty_bitmap));

        trace_mirror_restart_iter(s, bdrv_get_dirty_count(s->dirty_bitmap));

        assert(s->sector_num >= 0);

    }
@@ -288,8 +283,7 @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s) 
        next_sector += sectors_per_chunk;

    }



    bdrv_reset_dirty_bitmap(source, s->dirty_bitmap, sector_num,

                            nb_sectors);

    bdrv_reset_dirty_bitmap(s->dirty_bitmap, sector_num, nb_sectors);



    /* Copy the dirty cluster.  */

    s->in_flight++;
@@ -446,7 +440,7 @@ static void coroutine_fn mirror_run(void *opaque) 


            assert(n > 0);

            if (ret == 1) {

                bdrv_set_dirty_bitmap(bs, s->dirty_bitmap, sector_num, n);

                bdrv_set_dirty_bitmap(s->dirty_bitmap, sector_num, n);

                sector_num = next;

            } else {

                sector_num += n;
@@ -454,7 +448,7 @@ static void coroutine_fn mirror_run(void *opaque) 
        }

    }



    bdrv_dirty_iter_init(bs, s->dirty_bitmap, &s->hbi);

    bdrv_dirty_iter_init(s->dirty_bitmap, &s->hbi);

    last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);

    for (;;) {

        uint64_t delay_ns = 0;
@@ -466,7 +460,7 @@ static void coroutine_fn mirror_run(void *opaque) 
            goto immediate_exit;

        }



        cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);

        cnt = bdrv_get_dirty_count(s->dirty_bitmap);

        /* s->common.offset contains the number of bytes already processed so

         * far, cnt is the number of dirty sectors remaining and

         * s->sectors_in_flight is the number of sectors currently being
@@ -516,7 +510,7 @@ static void coroutine_fn mirror_run(void *opaque) 


                should_complete = s->should_complete ||

                    block_job_is_cancelled(&s->common);

                cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);

                cnt = bdrv_get_dirty_count(s->dirty_bitmap);

            }

        }
@@ -531,7 +525,7 @@ static void coroutine_fn mirror_run(void *opaque) 
             */

            trace_mirror_before_drain(s, cnt);

            bdrv_drain(bs);

            cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);

            cnt = bdrv_get_dirty_count(s->dirty_bitmap);

        }



        ret = 0;

blockdev.c

+1 −1
Original line number Diff line number Diff line
@@ -2072,7 +2072,7 @@ void qmp_block_dirty_bitmap_remove(const char *node, const char *name, 
                   name);

        goto out;

    }

    bdrv_dirty_bitmap_make_anon(bs, bitmap);

    bdrv_dirty_bitmap_make_anon(bitmap);

    bdrv_release_dirty_bitmap(bs, bitmap);



 out:

include/block/block.h

+5 −6
Original line number Diff line number Diff line
@@ -465,7 +465,7 @@ BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs, 
                                           Error **errp);

BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs,

                                        const char *name);

void bdrv_dirty_bitmap_make_anon(BlockDriverState *bs, BdrvDirtyBitmap *bitmap);

void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap);

void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap);

void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap);

void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap);
@@ -475,15 +475,14 @@ uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap); 
bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap);

bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap);

int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector);

void bdrv_set_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,

void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,

                           int64_t cur_sector, int nr_sectors);

void bdrv_reset_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,

void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,

                             int64_t cur_sector, int nr_sectors);

void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap);

void bdrv_dirty_iter_init(BlockDriverState *bs,

                          BdrvDirtyBitmap *bitmap, struct HBitmapIter *hbi);

void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, struct HBitmapIter *hbi);

void bdrv_set_dirty_iter(struct HBitmapIter *hbi, int64_t offset);

int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap);

int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap);



void bdrv_enable_copy_on_read(BlockDriverState *bs);

void bdrv_disable_copy_on_read(BlockDriverState *bs);