Commit 72d10a94 authored by Max Reitz's avatar Max Reitz
Browse files

block/dirty-bitmap: Add bdrv_dirty_iter_next_area 



This new function allows to look for a consecutively dirty area in a
dirty bitmap.

Signed-off-by: default avatarMax Reitz <mreitz@redhat.com>
Reviewed-by: default avatarFam Zheng <famz@redhat.com>
Reviewed-by: default avatarJohn Snow <jsnow@redhat.com>
Message-id: 20180613181823.13618-10-mreitz@redhat.com
Signed-off-by: default avatarMax Reitz <mreitz@redhat.com>
parent 26957684

block/dirty-bitmap.c

+55 −0
Original line number Diff line number Diff line
@@ -522,6 +522,61 @@ int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter) 
    return hbitmap_iter_next(&iter->hbi, true);

}



/**

 * Return the next consecutively dirty area in the dirty bitmap

 * belonging to the given iterator @iter.

 *

 * @max_offset: Maximum value that may be returned for

 *              *offset + *bytes

 * @offset:     Will contain the start offset of the next dirty area

 * @bytes:      Will contain the length of the next dirty area

 *

 * Returns: True if a dirty area could be found before max_offset

 *          (which means that *offset and *bytes then contain valid

 *          values), false otherwise.

 *

 * Note that @iter is never advanced if false is returned.  If an area

 * is found (which means that true is returned), it will be advanced

 * past that area.

 */

bool bdrv_dirty_iter_next_area(BdrvDirtyBitmapIter *iter, uint64_t max_offset,

                               uint64_t *offset, int *bytes)

{

    uint32_t granularity = bdrv_dirty_bitmap_granularity(iter->bitmap);

    uint64_t gran_max_offset;

    int64_t ret;

    int size;



    if (max_offset == iter->bitmap->size) {

        /* If max_offset points to the image end, round it up by the

         * bitmap granularity */

        gran_max_offset = ROUND_UP(max_offset, granularity);

    } else {

        gran_max_offset = max_offset;

    }



    ret = hbitmap_iter_next(&iter->hbi, false);

    if (ret < 0 || ret + granularity > gran_max_offset) {

        return false;

    }



    *offset = ret;

    size = 0;



    assert(granularity <= INT_MAX);



    do {

        /* Advance iterator */

        ret = hbitmap_iter_next(&iter->hbi, true);

        size += granularity;

    } while (ret + granularity <= gran_max_offset &&

             hbitmap_iter_next(&iter->hbi, false) == ret + granularity &&

             size <= INT_MAX - granularity);



    *bytes = MIN(size, max_offset - *offset);

    return true;

}



/* Called within bdrv_dirty_bitmap_lock..unlock */

void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,

                                  int64_t offset, int64_t bytes)

include/block/dirty-bitmap.h

+2 −0
Original line number Diff line number Diff line
@@ -82,6 +82,8 @@ void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap, 
void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,

                                    int64_t offset, int64_t bytes);

int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter);

bool bdrv_dirty_iter_next_area(BdrvDirtyBitmapIter *iter, uint64_t max_offset,

                               uint64_t *offset, int *bytes);

void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *hbi, int64_t offset);

int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap);

int64_t bdrv_get_meta_dirty_count(BdrvDirtyBitmap *bitmap);