Commit 397f4e9d authored by Vladimir Sementsov-Ogievskiy's avatar Vladimir Sementsov-Ogievskiy Committed by Max Reitz
Browse files

block/block-copy: hide structure definitions 



Hide structure definitions and add explicit API instead, to keep an
eye on the scope of the shared fields.

Signed-off-by: default avatarVladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: default avatarAndrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
Message-Id: <20200311103004.7649-10-vsementsov@virtuozzo.com>
Signed-off-by: default avatarMax Reitz <mreitz@redhat.com>
parent 5332e5d2

block/backup-top.c

+4 −2
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ typedef struct BDRVBackupTopState { 
    BlockCopyState *bcs;

    BdrvChild *target;

    bool active;

    int64_t cluster_size;

} BDRVBackupTopState;



static coroutine_fn int backup_top_co_preadv(
@@ -57,8 +58,8 @@ static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset, 
        return 0;

    }



    off = QEMU_ALIGN_DOWN(offset, s->bcs->cluster_size);

    end = QEMU_ALIGN_UP(offset + bytes, s->bcs->cluster_size);

    off = QEMU_ALIGN_DOWN(offset, s->cluster_size);

    end = QEMU_ALIGN_UP(offset + bytes, s->cluster_size);



    return block_copy(s->bcs, off, end - off, NULL);

}
@@ -238,6 +239,7 @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source, 
        goto fail;

    }



    state->cluster_size = cluster_size;

    state->bcs = block_copy_state_new(top->backing, state->target,

                                      cluster_size, write_flags, &local_err);

    if (local_err) {

block/backup.c

+13 −12
Original line number Diff line number Diff line
@@ -102,7 +102,7 @@ static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret) 


    if (ret < 0 && job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS) {

        /* If we failed and synced, merge in the bits we didn't copy: */

        bdrv_dirty_bitmap_merge_internal(bm, job->bcs->copy_bitmap,

        bdrv_dirty_bitmap_merge_internal(bm, block_copy_dirty_bitmap(job->bcs),

                                         NULL, true);

    }

}
@@ -145,7 +145,8 @@ void backup_do_checkpoint(BlockJob *job, Error **errp) 
        return;

    }



    bdrv_set_dirty_bitmap(backup_job->bcs->copy_bitmap, 0, backup_job->len);

    bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job->bcs), 0,

                          backup_job->len);

}



static BlockErrorAction backup_error_action(BackupBlockJob *job,
@@ -190,7 +191,7 @@ static int coroutine_fn backup_loop(BackupBlockJob *job) 
    BdrvDirtyBitmapIter *bdbi;

    int ret = 0;



    bdbi = bdrv_dirty_iter_new(job->bcs->copy_bitmap);

    bdbi = bdrv_dirty_iter_new(block_copy_dirty_bitmap(job->bcs));

    while ((offset = bdrv_dirty_iter_next(bdbi)) != -1) {

        do {

            if (yield_and_check(job)) {
@@ -210,14 +211,14 @@ static int coroutine_fn backup_loop(BackupBlockJob *job) 
    return ret;

}



static void backup_init_copy_bitmap(BackupBlockJob *job)

static void backup_init_bcs_bitmap(BackupBlockJob *job)

{

    bool ret;

    uint64_t estimate;

    BdrvDirtyBitmap *bcs_bitmap = block_copy_dirty_bitmap(job->bcs);



    if (job->sync_mode == MIRROR_SYNC_MODE_BITMAP) {

        ret = bdrv_dirty_bitmap_merge_internal(job->bcs->copy_bitmap,

                                               job->sync_bitmap,

        ret = bdrv_dirty_bitmap_merge_internal(bcs_bitmap, job->sync_bitmap,

                                               NULL, true);

        assert(ret);

    } else {
@@ -226,12 +227,12 @@ static void backup_init_copy_bitmap(BackupBlockJob *job) 
             * We can't hog the coroutine to initialize this thoroughly.

             * Set a flag and resume work when we are able to yield safely.

             */

            job->bcs->skip_unallocated = true;

            block_copy_set_skip_unallocated(job->bcs, true);

        }

        bdrv_set_dirty_bitmap(job->bcs->copy_bitmap, 0, job->len);

        bdrv_set_dirty_bitmap(bcs_bitmap, 0, job->len);

    }



    estimate = bdrv_get_dirty_count(job->bcs->copy_bitmap);

    estimate = bdrv_get_dirty_count(bcs_bitmap);

    job_progress_set_remaining(&job->common.job, estimate);

}
@@ -240,7 +241,7 @@ static int coroutine_fn backup_run(Job *job, Error **errp) 
    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);

    int ret = 0;



    backup_init_copy_bitmap(s);

    backup_init_bcs_bitmap(s);



    if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {

        int64_t offset = 0;
@@ -259,12 +260,12 @@ static int coroutine_fn backup_run(Job *job, Error **errp) 


            offset += count;

        }

        s->bcs->skip_unallocated = false;

        block_copy_set_skip_unallocated(s->bcs, false);

    }



    if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {

        /*

         * All bits are set in copy_bitmap to allow any cluster to be copied.

         * All bits are set in bcs bitmap to allow any cluster to be copied.

         * This does not actually require them to be copied.

         */

        while (!job_is_cancelled(job)) {

block/block-copy.c

+59 −0
Original line number Diff line number Diff line
@@ -24,6 +24,55 @@ 
#define BLOCK_COPY_MAX_BUFFER (1 * MiB)

#define BLOCK_COPY_MAX_MEM (128 * MiB)



typedef struct BlockCopyInFlightReq {

    int64_t offset;

    int64_t bytes;

    QLIST_ENTRY(BlockCopyInFlightReq) list;

    CoQueue wait_queue; /* coroutines blocked on this request */

} BlockCopyInFlightReq;



typedef struct BlockCopyState {

    /*

     * BdrvChild objects are not owned or managed by block-copy. They are

     * provided by block-copy user and user is responsible for appropriate

     * permissions on these children.

     */

    BdrvChild *source;

    BdrvChild *target;

    BdrvDirtyBitmap *copy_bitmap;

    int64_t in_flight_bytes;

    int64_t cluster_size;

    bool use_copy_range;

    int64_t copy_size;

    uint64_t len;

    QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs;



    BdrvRequestFlags write_flags;



    /*

     * skip_unallocated:

     *

     * Used by sync=top jobs, which first scan the source node for unallocated

     * areas and clear them in the copy_bitmap.  During this process, the bitmap

     * is thus not fully initialized: It may still have bits set for areas that

     * are unallocated and should actually not be copied.

     *

     * This is indicated by skip_unallocated.

     *

     * In this case, block_copy() will query the source’s allocation status,

     * skip unallocated regions, clear them in the copy_bitmap, and invoke

     * block_copy_reset_unallocated() every time it does.

     */

    bool skip_unallocated;



    ProgressMeter *progress;

    /* progress_bytes_callback: called when some copying progress is done. */

    ProgressBytesCallbackFunc progress_bytes_callback;

    void *progress_opaque;



    SharedResource *mem;

} BlockCopyState;



static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,

                                                           int64_t offset,

                                                           int64_t bytes)
@@ -517,3 +566,13 @@ int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes, 


    return ret;

}



BdrvDirtyBitmap *block_copy_dirty_bitmap(BlockCopyState *s)

{

    return s->copy_bitmap;

}



void block_copy_set_skip_unallocated(BlockCopyState *s, bool skip)

{

    s->skip_unallocated = skip;

}

include/block/block-copy.h

+4 −48
Original line number Diff line number Diff line
@@ -18,55 +18,8 @@ 
#include "block/block.h"

#include "qemu/co-shared-resource.h"



typedef struct BlockCopyInFlightReq {

    int64_t offset;

    int64_t bytes;

    QLIST_ENTRY(BlockCopyInFlightReq) list;

    CoQueue wait_queue; /* coroutines blocked on this request */

} BlockCopyInFlightReq;



typedef void (*ProgressBytesCallbackFunc)(int64_t bytes, void *opaque);

typedef struct BlockCopyState {

    /*

     * BdrvChild objects are not owned or managed by block-copy. They are

     * provided by block-copy user and user is responsible for appropriate

     * permissions on these children.

     */

    BdrvChild *source;

    BdrvChild *target;

    BdrvDirtyBitmap *copy_bitmap;

    int64_t in_flight_bytes;

    int64_t cluster_size;

    bool use_copy_range;

    int64_t copy_size;

    uint64_t len;

    QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs;



    BdrvRequestFlags write_flags;



    /*

     * skip_unallocated:

     *

     * Used by sync=top jobs, which first scan the source node for unallocated

     * areas and clear them in the copy_bitmap.  During this process, the bitmap

     * is thus not fully initialized: It may still have bits set for areas that

     * are unallocated and should actually not be copied.

     *

     * This is indicated by skip_unallocated.

     *

     * In this case, block_copy() will query the source’s allocation status,

     * skip unallocated regions, clear them in the copy_bitmap, and invoke

     * block_copy_reset_unallocated() every time it does.

     */

    bool skip_unallocated;



    ProgressMeter *progress;

    /* progress_bytes_callback: called when some copying progress is done. */

    ProgressBytesCallbackFunc progress_bytes_callback;

    void *progress_opaque;



    SharedResource *mem;

} BlockCopyState;

typedef struct BlockCopyState BlockCopyState;



BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,

                                     int64_t cluster_size,
@@ -88,4 +41,7 @@ int64_t block_copy_reset_unallocated(BlockCopyState *s, 
int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,

                            bool *error_is_read);



BdrvDirtyBitmap *block_copy_dirty_bitmap(BlockCopyState *s);

void block_copy_set_skip_unallocated(BlockCopyState *s, bool skip);



#endif /* BLOCK_COPY_H */