Commit 94c56652 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 Mon 10 Jul 2017 12:26:44 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: (40 commits)
  block: Make bdrv_is_allocated_above() byte-based
  block: Minimize raw use of bds->total_sectors
  block: Make bdrv_is_allocated() byte-based
  backup: Switch backup_run() to byte-based
  backup: Switch backup_do_cow() to byte-based
  backup: Switch block_backup.h to byte-based
  backup: Switch BackupBlockJob to byte-based
  block: Drop unused bdrv_round_sectors_to_clusters()
  mirror: Switch mirror_iteration() to byte-based
  mirror: Switch mirror_do_read() to byte-based
  mirror: Switch mirror_cow_align() to byte-based
  mirror: Update signature of mirror_clip_sectors()
  mirror: Switch mirror_do_zero_or_discard() to byte-based
  mirror: Switch MirrorBlockJob to byte-based
  commit: Switch commit_run() to byte-based
  commit: Switch commit_populate() to byte-based
  stream: Switch stream_run() to byte-based
  stream: Drop reached_end for stream_complete()
  stream: Switch stream_populate() to byte-based
  trace: Show blockjob actions via bytes, not sectors
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 6580476a 51b0a488

block/backup.c

+55 −73
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ typedef struct BackupBlockJob { 
    BlockdevOnError on_source_error;

    BlockdevOnError on_target_error;

    CoRwlock flush_rwlock;

    uint64_t sectors_read;

    uint64_t bytes_read;

    unsigned long *done_bitmap;

    int64_t cluster_size;

    bool compress;
@@ -47,12 +47,6 @@ typedef struct BackupBlockJob { 
    QLIST_HEAD(, CowRequest) inflight_reqs;

} BackupBlockJob;



/* Size of a cluster in sectors, instead of bytes. */

static inline int64_t cluster_size_sectors(BackupBlockJob *job)

{

  return job->cluster_size / BDRV_SECTOR_SIZE;

}



/* See if in-flight requests overlap and wait for them to complete */

static void coroutine_fn wait_for_overlapping_requests(BackupBlockJob *job,

                                                       int64_t start,
@@ -64,7 +58,7 @@ static void coroutine_fn wait_for_overlapping_requests(BackupBlockJob *job, 
    do {

        retry = false;

        QLIST_FOREACH(req, &job->inflight_reqs, list) {

            if (end > req->start && start < req->end) {

            if (end > req->start_byte && start < req->end_byte) {

                qemu_co_queue_wait(&req->wait_queue, NULL);

                retry = true;

                break;
@@ -77,8 +71,8 @@ static void coroutine_fn wait_for_overlapping_requests(BackupBlockJob *job, 
static void cow_request_begin(CowRequest *req, BackupBlockJob *job,

                              int64_t start, int64_t end)

{

    req->start = start;

    req->end = end;

    req->start_byte = start;

    req->end_byte = end;

    qemu_co_queue_init(&req->wait_queue);

    QLIST_INSERT_HEAD(&job->inflight_reqs, req, list);

}
@@ -91,7 +85,7 @@ static void cow_request_end(CowRequest *req) 
}



static int coroutine_fn backup_do_cow(BackupBlockJob *job,

                                      int64_t sector_num, int nb_sectors,

                                      int64_t offset, uint64_t bytes,

                                      bool *error_is_read,

                                      bool is_write_notifier)

{
@@ -101,41 +95,37 @@ static int coroutine_fn backup_do_cow(BackupBlockJob *job, 
    QEMUIOVector bounce_qiov;

    void *bounce_buffer = NULL;

    int ret = 0;

    int64_t sectors_per_cluster = cluster_size_sectors(job);

    int64_t start, end;

    int n;

    int64_t start, end; /* bytes */

    int n; /* bytes */



    qemu_co_rwlock_rdlock(&job->flush_rwlock);



    start = sector_num / sectors_per_cluster;

    end = DIV_ROUND_UP(sector_num + nb_sectors, sectors_per_cluster);

    start = QEMU_ALIGN_DOWN(offset, job->cluster_size);

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



    trace_backup_do_cow_enter(job, start, sector_num, nb_sectors);

    trace_backup_do_cow_enter(job, start, offset, bytes);



    wait_for_overlapping_requests(job, start, end);

    cow_request_begin(&cow_request, job, start, end);



    for (; start < end; start++) {

        if (test_bit(start, job->done_bitmap)) {

    for (; start < end; start += job->cluster_size) {

        if (test_bit(start / job->cluster_size, job->done_bitmap)) {

            trace_backup_do_cow_skip(job, start);

            continue; /* already copied */

        }



        trace_backup_do_cow_process(job, start);



        n = MIN(sectors_per_cluster,

                job->common.len / BDRV_SECTOR_SIZE -

                start * sectors_per_cluster);

        n = MIN(job->cluster_size, job->common.len - start);



        if (!bounce_buffer) {

            bounce_buffer = blk_blockalign(blk, job->cluster_size);

        }

        iov.iov_base = bounce_buffer;

        iov.iov_len = n * BDRV_SECTOR_SIZE;

        iov.iov_len = n;

        qemu_iovec_init_external(&bounce_qiov, &iov, 1);



        ret = blk_co_preadv(blk, start * job->cluster_size,

                            bounce_qiov.size, &bounce_qiov,

        ret = blk_co_preadv(blk, start, bounce_qiov.size, &bounce_qiov,

                            is_write_notifier ? BDRV_REQ_NO_SERIALISING : 0);

        if (ret < 0) {

            trace_backup_do_cow_read_fail(job, start, ret);
@@ -146,10 +136,10 @@ static int coroutine_fn backup_do_cow(BackupBlockJob *job, 
        }



        if (buffer_is_zero(iov.iov_base, iov.iov_len)) {

            ret = blk_co_pwrite_zeroes(job->target, start * job->cluster_size,

            ret = blk_co_pwrite_zeroes(job->target, start,

                                       bounce_qiov.size, BDRV_REQ_MAY_UNMAP);

        } else {

            ret = blk_co_pwritev(job->target, start * job->cluster_size,

            ret = blk_co_pwritev(job->target, start,

                                 bounce_qiov.size, &bounce_qiov,

                                 job->compress ? BDRV_REQ_WRITE_COMPRESSED : 0);

        }
@@ -161,13 +151,13 @@ static int coroutine_fn backup_do_cow(BackupBlockJob *job, 
            goto out;

        }



        set_bit(start, job->done_bitmap);

        set_bit(start / job->cluster_size, job->done_bitmap);



        /* Publish progress, guest I/O counts as progress too.  Note that the

         * offset field is an opaque progress value, it is not a disk offset.

         */

        job->sectors_read += n;

        job->common.offset += n * BDRV_SECTOR_SIZE;

        job->bytes_read += n;

        job->common.offset += n;

    }



out:
@@ -177,7 +167,7 @@ out: 


    cow_request_end(&cow_request);



    trace_backup_do_cow_return(job, sector_num, nb_sectors, ret);

    trace_backup_do_cow_return(job, offset, bytes, ret);



    qemu_co_rwlock_unlock(&job->flush_rwlock);
@@ -190,14 +180,12 @@ static int coroutine_fn backup_before_write_notify( 
{

    BackupBlockJob *job = container_of(notifier, BackupBlockJob, before_write);

    BdrvTrackedRequest *req = opaque;

    int64_t sector_num = req->offset >> BDRV_SECTOR_BITS;

    int nb_sectors = req->bytes >> BDRV_SECTOR_BITS;



    assert(req->bs == blk_bs(job->common.blk));

    assert((req->offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((req->bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(QEMU_IS_ALIGNED(req->offset, BDRV_SECTOR_SIZE));

    assert(QEMU_IS_ALIGNED(req->bytes, BDRV_SECTOR_SIZE));



    return backup_do_cow(job, sector_num, nb_sectors, NULL, true);

    return backup_do_cow(job, req->offset, req->bytes, NULL, true);

}



static void backup_set_speed(BlockJob *job, int64_t speed, Error **errp)
@@ -208,7 +196,7 @@ static void backup_set_speed(BlockJob *job, int64_t speed, Error **errp) 
        error_setg(errp, QERR_INVALID_PARAMETER, "speed");

        return;

    }

    ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);

    ratelimit_set_speed(&s->limit, speed, SLICE_TIME);

}



static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
@@ -275,32 +263,29 @@ void backup_do_checkpoint(BlockJob *job, Error **errp) 
    bitmap_zero(backup_job->done_bitmap, len);

}



void backup_wait_for_overlapping_requests(BlockJob *job, int64_t sector_num,

                                          int nb_sectors)

void backup_wait_for_overlapping_requests(BlockJob *job, int64_t offset,

                                          uint64_t bytes)

{

    BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);

    int64_t sectors_per_cluster = cluster_size_sectors(backup_job);

    int64_t start, end;



    assert(job->driver->job_type == BLOCK_JOB_TYPE_BACKUP);



    start = sector_num / sectors_per_cluster;

    end = DIV_ROUND_UP(sector_num + nb_sectors, sectors_per_cluster);

    start = QEMU_ALIGN_DOWN(offset, backup_job->cluster_size);

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

    wait_for_overlapping_requests(backup_job, start, end);

}



void backup_cow_request_begin(CowRequest *req, BlockJob *job,

                              int64_t sector_num,

                              int nb_sectors)

                              int64_t offset, uint64_t bytes)

{

    BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);

    int64_t sectors_per_cluster = cluster_size_sectors(backup_job);

    int64_t start, end;



    assert(job->driver->job_type == BLOCK_JOB_TYPE_BACKUP);



    start = sector_num / sectors_per_cluster;

    end = DIV_ROUND_UP(sector_num + nb_sectors, sectors_per_cluster);

    start = QEMU_ALIGN_DOWN(offset, backup_job->cluster_size);

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

    cow_request_begin(req, backup_job, start, end);

}
@@ -359,8 +344,8 @@ static bool coroutine_fn yield_and_check(BackupBlockJob *job) 
     */

    if (job->common.speed) {

        uint64_t delay_ns = ratelimit_calculate_delay(&job->limit,

                                                      job->sectors_read);

        job->sectors_read = 0;

                                                      job->bytes_read);

        job->bytes_read = 0;

        block_job_sleep_ns(&job->common, QEMU_CLOCK_REALTIME, delay_ns);

    } else {

        block_job_sleep_ns(&job->common, QEMU_CLOCK_REALTIME, 0);
@@ -379,11 +364,10 @@ static int coroutine_fn backup_run_incremental(BackupBlockJob *job) 
    int ret = 0;

    int clusters_per_iter;

    uint32_t granularity;

    int64_t sector;

    int64_t offset;

    int64_t cluster;

    int64_t end;

    int64_t last_cluster = -1;

    int64_t sectors_per_cluster = cluster_size_sectors(job);

    BdrvDirtyBitmapIter *dbi;



    granularity = bdrv_dirty_bitmap_granularity(job->sync_bitmap);
@@ -391,8 +375,8 @@ static int coroutine_fn backup_run_incremental(BackupBlockJob *job) 
    dbi = bdrv_dirty_iter_new(job->sync_bitmap, 0);



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

    while ((sector = bdrv_dirty_iter_next(dbi)) != -1) {

        cluster = sector / sectors_per_cluster;

    while ((offset = bdrv_dirty_iter_next(dbi) * BDRV_SECTOR_SIZE) >= 0) {

        cluster = offset / job->cluster_size;



        /* Fake progress updates for any clusters we skipped */

        if (cluster != last_cluster + 1) {
@@ -405,8 +389,8 @@ static int coroutine_fn backup_run_incremental(BackupBlockJob *job) 
                if (yield_and_check(job)) {

                    goto out;

                }

                ret = backup_do_cow(job, cluster * sectors_per_cluster,

                                    sectors_per_cluster, &error_is_read,

                ret = backup_do_cow(job, cluster * job->cluster_size,

                                    job->cluster_size, &error_is_read,

                                    false);

                if ((ret < 0) &&

                    backup_error_action(job, error_is_read, -ret) ==
@@ -419,7 +403,8 @@ static int coroutine_fn backup_run_incremental(BackupBlockJob *job) 
        /* If the bitmap granularity is smaller than the backup granularity,

         * we need to advance the iterator pointer to the next cluster. */

        if (granularity < job->cluster_size) {

            bdrv_set_dirty_iter(dbi, cluster * sectors_per_cluster);

            bdrv_set_dirty_iter(dbi,

                                cluster * job->cluster_size / BDRV_SECTOR_SIZE);

        }



        last_cluster = cluster - 1;
@@ -441,17 +426,14 @@ static void coroutine_fn backup_run(void *opaque) 
    BackupBlockJob *job = opaque;

    BackupCompleteData *data;

    BlockDriverState *bs = blk_bs(job->common.blk);

    int64_t start, end;

    int64_t sectors_per_cluster = cluster_size_sectors(job);

    int64_t offset;

    int ret = 0;



    QLIST_INIT(&job->inflight_reqs);

    qemu_co_rwlock_init(&job->flush_rwlock);



    start = 0;

    end = DIV_ROUND_UP(job->common.len, job->cluster_size);



    job->done_bitmap = bitmap_new(end);

    job->done_bitmap = bitmap_new(DIV_ROUND_UP(job->common.len,

                                               job->cluster_size));



    job->before_write.notify = backup_before_write_notify;

    bdrv_add_before_write_notifier(bs, &job->before_write);
@@ -466,7 +448,8 @@ static void coroutine_fn backup_run(void *opaque) 
        ret = backup_run_incremental(job);

    } else {

        /* Both FULL and TOP SYNC_MODE's require copying.. */

        for (; start < end; start++) {

        for (offset = 0; offset < job->common.len;

             offset += job->cluster_size) {

            bool error_is_read;

            int alloced = 0;
@@ -475,12 +458,13 @@ static void coroutine_fn backup_run(void *opaque) 
            }



            if (job->sync_mode == MIRROR_SYNC_MODE_TOP) {

                int i, n;

                int i;

                int64_t n;



                /* Check to see if these blocks are already in the

                 * backing file. */



                for (i = 0; i < sectors_per_cluster;) {

                for (i = 0; i < job->cluster_size;) {

                    /* bdrv_is_allocated() only returns true/false based

                     * on the first set of sectors it comes across that

                     * are are all in the same state.
@@ -488,9 +472,8 @@ static void coroutine_fn backup_run(void *opaque) 
                     * backup cluster length.  We end up copying more than

                     * needed but at some point that is always the case. */

                    alloced =

                        bdrv_is_allocated(bs,

                                start * sectors_per_cluster + i,

                                sectors_per_cluster - i, &n);

                        bdrv_is_allocated(bs, offset + i,

                                          job->cluster_size - i, &n);

                    i += n;



                    if (alloced || n == 0) {
@@ -508,9 +491,8 @@ static void coroutine_fn backup_run(void *opaque) 
            if (alloced < 0) {

                ret = alloced;

            } else {

                ret = backup_do_cow(job, start * sectors_per_cluster,

                                    sectors_per_cluster, &error_is_read,

                                    false);

                ret = backup_do_cow(job, offset, job->cluster_size,

                                    &error_is_read, false);

            }

            if (ret < 0) {

                /* Depending on error action, fail now or retry cluster */
@@ -519,7 +501,7 @@ static void coroutine_fn backup_run(void *opaque) 
                if (action == BLOCK_ERROR_ACTION_REPORT) {

                    break;

                } else {

                    start--;

                    offset -= job->cluster_size;

                    continue;

                }

            }

block/blkdebug.c

+11 −0
Original line number Diff line number Diff line
@@ -641,6 +641,16 @@ 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;
@@ -915,6 +925,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_debug_event           = blkdebug_debug_event,

    .bdrv_debug_breakpoint      = blkdebug_debug_breakpoint,

block/commit.c

+24 −32
Original line number Diff line number Diff line
@@ -47,26 +47,25 @@ typedef struct CommitBlockJob { 
} CommitBlockJob;



static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base,

                                        int64_t sector_num, int nb_sectors,

                                        int64_t offset, uint64_t bytes,

                                        void *buf)

{

    int ret = 0;

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base = buf,

        .iov_len = nb_sectors * BDRV_SECTOR_SIZE,

        .iov_len = bytes,

    };



    assert(bytes < SIZE_MAX);

    qemu_iovec_init_external(&qiov, &iov, 1);



    ret = blk_co_preadv(bs, sector_num * BDRV_SECTOR_SIZE,

                        qiov.size, &qiov, 0);

    ret = blk_co_preadv(bs, offset, qiov.size, &qiov, 0);

    if (ret < 0) {

        return ret;

    }



    ret = blk_co_pwritev(base, sector_num * BDRV_SECTOR_SIZE,

                         qiov.size, &qiov, 0);

    ret = blk_co_pwritev(base, offset, qiov.size, &qiov, 0);

    if (ret < 0) {

        return ret;

    }
@@ -144,17 +143,16 @@ static void coroutine_fn commit_run(void *opaque) 
{

    CommitBlockJob *s = opaque;

    CommitCompleteData *data;

    int64_t sector_num, end;

    int64_t offset;

    uint64_t delay_ns = 0;

    int ret = 0;

    int n = 0;

    int64_t n = 0; /* bytes */

    void *buf = NULL;

    int bytes_written = 0;

    int64_t base_len;



    ret = s->common.len = blk_getlength(s->top);





    if (s->common.len < 0) {

        goto out;

    }
@@ -171,10 +169,9 @@ static void coroutine_fn commit_run(void *opaque) 
        }

    }



    end = s->common.len >> BDRV_SECTOR_BITS;

    buf = blk_blockalign(s->top, COMMIT_BUFFER_SIZE);



    for (sector_num = 0; sector_num < end; sector_num += n) {

    for (offset = 0; offset < s->common.len; offset += n) {

        bool copy;



        /* Note that even when no rate limit is applied we need to yield
@@ -186,14 +183,12 @@ static void coroutine_fn commit_run(void *opaque) 
        }

        /* Copy if allocated above the base */

        ret = bdrv_is_allocated_above(blk_bs(s->top), blk_bs(s->base),

                                      sector_num,

                                      COMMIT_BUFFER_SIZE / BDRV_SECTOR_SIZE,

                                      &n);

                                      offset, COMMIT_BUFFER_SIZE, &n);

        copy = (ret == 1);

        trace_commit_one_iteration(s, sector_num, n, ret);

        trace_commit_one_iteration(s, offset, n, ret);

        if (copy) {

            ret = commit_populate(s->top, s->base, sector_num, n, buf);

            bytes_written += n * BDRV_SECTOR_SIZE;

            ret = commit_populate(s->top, s->base, offset, n, buf);

            bytes_written += n;

        }

        if (ret < 0) {

            BlockErrorAction action =
@@ -206,7 +201,7 @@ static void coroutine_fn commit_run(void *opaque) 
            }

        }

        /* Publish progress */

        s->common.offset += n * BDRV_SECTOR_SIZE;

        s->common.offset += n;



        if (copy && s->common.speed) {

            delay_ns = ratelimit_calculate_delay(&s->limit, n);
@@ -231,7 +226,7 @@ static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp) 
        error_setg(errp, QERR_INVALID_PARAMETER, "speed");

        return;

    }

    ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);

    ratelimit_set_speed(&s->limit, speed, SLICE_TIME);

}



static const BlockJobDriver commit_job_driver = {
@@ -253,7 +248,7 @@ static int64_t coroutine_fn bdrv_commit_top_get_block_status( 
{

    *pnum = nb_sectors;

    *file = bs->backing->bs;

    return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_DATA |

    return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID |

           (sector_num << BDRV_SECTOR_BITS);

}
@@ -444,7 +439,7 @@ fail: 
}





#define COMMIT_BUF_SECTORS 2048

#define COMMIT_BUF_SIZE (2048 * BDRV_SECTOR_SIZE)



/* commit COW file into the raw image */

int bdrv_commit(BlockDriverState *bs)
@@ -453,8 +448,9 @@ int bdrv_commit(BlockDriverState *bs) 
    BlockDriverState *backing_file_bs = NULL;

    BlockDriverState *commit_top_bs = NULL;

    BlockDriver *drv = bs->drv;

    int64_t sector, total_sectors, length, backing_length;

    int n, ro, open_flags;

    int64_t offset, length, backing_length;

    int ro, open_flags;

    int64_t n;

    int ret = 0;

    uint8_t *buf = NULL;

    Error *local_err = NULL;
@@ -532,30 +528,26 @@ int bdrv_commit(BlockDriverState *bs) 
        }

    }



    total_sectors = length >> BDRV_SECTOR_BITS;



    /* blk_try_blockalign() for src will choose an alignment that works for

     * backing as well, so no need to compare the alignment manually. */

    buf = blk_try_blockalign(src, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);

    buf = blk_try_blockalign(src, COMMIT_BUF_SIZE);

    if (buf == NULL) {

        ret = -ENOMEM;

        goto ro_cleanup;

    }



    for (sector = 0; sector < total_sectors; sector += n) {

        ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);

    for (offset = 0; offset < length; offset += n) {

        ret = bdrv_is_allocated(bs, offset, COMMIT_BUF_SIZE, &n);

        if (ret < 0) {

            goto ro_cleanup;

        }

        if (ret) {

            ret = blk_pread(src, sector * BDRV_SECTOR_SIZE, buf,

                            n * BDRV_SECTOR_SIZE);

            ret = blk_pread(src, offset, buf, n);

            if (ret < 0) {

                goto ro_cleanup;

            }



            ret = blk_pwrite(backing, sector * BDRV_SECTOR_SIZE, buf,

                             n * BDRV_SECTOR_SIZE, 0);

            ret = blk_pwrite(backing, offset, buf, n, 0);

            if (ret < 0) {

                goto ro_cleanup;

            }

block/io.c

+48 −54
Original line number Diff line number Diff line
@@ -418,27 +418,6 @@ static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align) 
    req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);

}



/**

 * Round a region to cluster boundaries (sector-based)

 */

void bdrv_round_sectors_to_clusters(BlockDriverState *bs,

                                    int64_t sector_num, int nb_sectors,

                                    int64_t *cluster_sector_num,

                                    int *cluster_nb_sectors)

{

    BlockDriverInfo bdi;



    if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {

        *cluster_sector_num = sector_num;

        *cluster_nb_sectors = nb_sectors;

    } else {

        int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;

        *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);

        *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +

                                            nb_sectors, c);

    }

}



/**

 * Round a region to cluster boundaries

 */
@@ -1054,17 +1033,18 @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child, 
    }



    if (flags & BDRV_REQ_COPY_ON_READ) {

        int64_t start_sector = offset >> BDRV_SECTOR_BITS;

        int64_t end_sector = DIV_ROUND_UP(offset + bytes, BDRV_SECTOR_SIZE);

        unsigned int nb_sectors = end_sector - start_sector;

        int pnum;

        /* TODO: Simplify further once bdrv_is_allocated no longer

         * requires sector alignment */

        int64_t start = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);

        int64_t end = QEMU_ALIGN_UP(offset + bytes, BDRV_SECTOR_SIZE);

        int64_t pnum;



        ret = bdrv_is_allocated(bs, start_sector, nb_sectors, &pnum);

        ret = bdrv_is_allocated(bs, start, end - start, &pnum);

        if (ret < 0) {

            goto out;

        }



        if (!ret || pnum != nb_sectors) {

        if (!ret || pnum != end - start) {

            ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov);

            goto out;

        }
@@ -1734,6 +1714,7 @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs, 
    int64_t n;

    int64_t ret, ret2;



    *file = NULL;

    total_sectors = bdrv_nb_sectors(bs);

    if (total_sectors < 0) {

        return total_sectors;
@@ -1757,11 +1738,11 @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs, 
        }

        if (bs->drv->protocol_name) {

            ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);

            *file = bs;

        }

        return ret;

    }



    *file = NULL;

    bdrv_inc_in_flight(bs);

    ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum,

                                            file);
@@ -1771,7 +1752,7 @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs, 
    }



    if (ret & BDRV_BLOCK_RAW) {

        assert(ret & BDRV_BLOCK_OFFSET_VALID);

        assert(ret & BDRV_BLOCK_OFFSET_VALID && *file);

        ret = bdrv_co_get_block_status(*file, ret >> BDRV_SECTOR_BITS,

                                       *pnum, pnum, file);

        goto out;
@@ -1920,59 +1901,72 @@ int64_t bdrv_get_block_status(BlockDriverState *bs, 
                                       sector_num, nb_sectors, pnum, file);

}



int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,

                                   int nb_sectors, int *pnum)

int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,

                                   int64_t bytes, int64_t *pnum)

{

    BlockDriverState *file;

    int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum,

    int64_t sector_num = offset >> BDRV_SECTOR_BITS;

    int nb_sectors = bytes >> BDRV_SECTOR_BITS;

    int64_t ret;

    int psectors;



    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));

    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE) && bytes < INT_MAX);

    ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &psectors,

                                &file);

    if (ret < 0) {

        return ret;

    }

    if (pnum) {

        *pnum = psectors * BDRV_SECTOR_SIZE;

    }

    return !!(ret & BDRV_BLOCK_ALLOCATED);

}



/*

 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]

 *

 * Return true if the given sector is allocated in any image between

 * BASE and TOP (inclusive).  BASE can be NULL to check if the given

 * sector is allocated in any image of the chain.  Return false otherwise.

 * Return true if (a prefix of) the given range is allocated in any image

 * between BASE and TOP (inclusive).  BASE can be NULL to check if the given

 * offset is allocated in any image of the chain.  Return false otherwise,

 * or negative errno on failure.

 *

 * 'pnum' is set to the number of sectors (including and immediately following

 *  the specified sector) that are known to be in the same

 *  allocated/unallocated state.

 * 'pnum' is set to the number of bytes (including and immediately

 * following the specified offset) that are known to be in the same

 * allocated/unallocated state.  Note that a subsequent call starting

 * at 'offset + *pnum' may return the same allocation status (in other

 * words, the result is not necessarily the maximum possible range);

 * but 'pnum' will only be 0 when end of file is reached.

 *

 */

int bdrv_is_allocated_above(BlockDriverState *top,

                            BlockDriverState *base,

                            int64_t sector_num,

                            int nb_sectors, int *pnum)

                            int64_t offset, int64_t bytes, int64_t *pnum)

{

    BlockDriverState *intermediate;

    int ret, n = nb_sectors;

    int ret;

    int64_t n = bytes;



    intermediate = top;

    while (intermediate && intermediate != base) {

        int pnum_inter;

        ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,

                                &pnum_inter);

        int64_t pnum_inter;

        int64_t size_inter;



        ret = bdrv_is_allocated(intermediate, offset, bytes, &pnum_inter);

        if (ret < 0) {

            return ret;

        } else if (ret) {

        }

        if (ret) {

            *pnum = pnum_inter;

            return 1;

        }



        /*

         * [sector_num, nb_sectors] is unallocated on top but intermediate

         * might have

         *

         * [sector_num+x, nr_sectors] allocated.

         */

        size_inter = bdrv_getlength(intermediate);

        if (size_inter < 0) {

            return size_inter;

        }

        if (n > pnum_inter &&

            (intermediate == top ||

             sector_num + pnum_inter < intermediate->total_sectors)) {

            (intermediate == top || offset + pnum_inter < size_inter)) {

            n = pnum_inter;

        }

block/mirror.c

+159 −151

File changed.

Preview size limit exceeded, changes collapsed.