Commit c416eece authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging 



Block layer patches:

- Switch AIO/callback based block drivers to a byte-based interface
- Block jobs: Expose error string via query-block-jobs
- Block job cleanups and fixes
- hmp: Allow using a qdev id in block_set_io_throttle

# gpg: Signature made Tue 15 May 2018 16:33:10 BST
# gpg:                using RSA key 7F09B272C88F2FD6
# 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: (37 commits)
  iotests: Add test for -U/force-share conflicts
  qemu-img: Use only string options in img_open_opts
  qemu-io: Use purely string blockdev options
  block: Document BDRV_REQ_WRITE_UNCHANGED support
  qemu-img: Check post-truncation size
  iotests: Add test for COR across nodes
  iotests: Copy 197 for COR filter driver
  iotests: Clean up wrap image in 197
  block: Support BDRV_REQ_WRITE_UNCHANGED in filters
  block/quorum: Support BDRV_REQ_WRITE_UNCHANGED
  block: Set BDRV_REQ_WRITE_UNCHANGED for COR writes
  block: Add BDRV_REQ_WRITE_UNCHANGED flag
  block: BLK_PERM_WRITE includes ..._UNCHANGED
  block: Add COR filter driver
  iotests: Skip 181 and 201 without userfaultfd
  iotests: Add failure matching to common.qemu
  docs: Document the new default sizes of the qcow2 caches
  qcow2: Give the refcount cache the minimum possible size by default
  specs/qcow2: Clarify that compressed clusters have the COPIED bit reset
  Fix error message about compressed clusters with OFLAG_COPIED
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 0275e6b6 1fce860e

block/Makefile.objs

+1 −1
Original line number Diff line number Diff line
@@ -26,7 +26,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 += throttle.o copy-on-read.o



block-obj-y += crypto.o

block/backup.c

+25 −37
Original line number Diff line number Diff line
@@ -27,7 +27,6 @@ 
#include "qemu/error-report.h"



#define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)

#define SLICE_TIME 100000000ULL /* ns */



typedef struct BackupBlockJob {

    BlockJob common;
@@ -35,10 +34,10 @@ typedef struct BackupBlockJob { 
    /* bitmap for sync=incremental */

    BdrvDirtyBitmap *sync_bitmap;

    MirrorSyncMode sync_mode;

    RateLimit limit;

    BlockdevOnError on_source_error;

    BlockdevOnError on_target_error;

    CoRwlock flush_rwlock;

    uint64_t len;

    uint64_t bytes_read;

    int64_t cluster_size;

    bool compress;
@@ -48,6 +47,8 @@ typedef struct BackupBlockJob { 
    HBitmap *copy_bitmap;

} BackupBlockJob;



static const BlockJobDriver backup_job_driver;



/* 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,
@@ -118,7 +119,7 @@ static int coroutine_fn backup_do_cow(BackupBlockJob *job, 


        trace_backup_do_cow_process(job, start);



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

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



        if (!bounce_buffer) {

            bounce_buffer = blk_blockalign(blk, job->cluster_size);
@@ -159,7 +160,7 @@ static int coroutine_fn backup_do_cow(BackupBlockJob *job, 
         * offset field is an opaque progress value, it is not a disk offset.

         */

        job->bytes_read += n;

        job->common.offset += n;

        block_job_progress_update(&job->common, n);

    }



out:
@@ -190,17 +191,6 @@ static int coroutine_fn backup_before_write_notify( 
    return backup_do_cow(job, req->offset, req->bytes, NULL, true);

}



static void backup_set_speed(BlockJob *job, int64_t speed, Error **errp)

{

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



    if (speed < 0) {

        error_setg(errp, QERR_INVALID_PARAMETER, "speed");

        return;

    }

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

}



static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)

{

    BdrvDirtyBitmap *bm;
@@ -253,7 +243,7 @@ void backup_do_checkpoint(BlockJob *job, Error **errp) 
    BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);

    int64_t len;



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

    assert(block_job_driver(job) == &backup_job_driver);



    if (backup_job->sync_mode != MIRROR_SYNC_MODE_NONE) {

        error_setg(errp, "The backup job only supports block checkpoint in"
@@ -261,7 +251,7 @@ void backup_do_checkpoint(BlockJob *job, Error **errp) 
        return;

    }



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

    len = DIV_ROUND_UP(backup_job->len, backup_job->cluster_size);

    hbitmap_set(backup_job->copy_bitmap, 0, len);

}
@@ -271,7 +261,7 @@ void backup_wait_for_overlapping_requests(BlockJob *job, int64_t offset, 
    BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);

    int64_t start, end;



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

    assert(block_job_driver(job) == &backup_job_driver);



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

    end = QEMU_ALIGN_UP(offset + bytes, backup_job->cluster_size);
@@ -284,7 +274,7 @@ void backup_cow_request_begin(CowRequest *req, BlockJob *job, 
    BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);

    int64_t start, end;



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

    assert(block_job_driver(job) == &backup_job_driver);



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

    end = QEMU_ALIGN_UP(offset + bytes, backup_job->cluster_size);
@@ -337,21 +327,17 @@ static void backup_complete(BlockJob *job, void *opaque) 


static bool coroutine_fn yield_and_check(BackupBlockJob *job)

{

    uint64_t delay_ns;



    if (block_job_is_cancelled(&job->common)) {

        return true;

    }



    /* we need to yield so that bdrv_drain_all() returns.

     * (without, VM does not reboot)

     */

    if (job->common.speed) {

        uint64_t delay_ns = ratelimit_calculate_delay(&job->limit,

                                                      job->bytes_read);

    /* We need to yield even for delay_ns = 0 so that bdrv_drain_all() can

     * return. Without a yield, the VM would not reboot. */

    delay_ns = block_job_ratelimit_get_delay(&job->common, job->bytes_read);

    job->bytes_read = 0;

    block_job_sleep_ns(&job->common, delay_ns);

    } else {

        block_job_sleep_ns(&job->common, 0);

    }



    if (block_job_is_cancelled(&job->common)) {

        return true;
@@ -420,8 +406,9 @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job) 
        bdrv_set_dirty_iter(dbi, next_cluster * job->cluster_size);

    }



    job->common.offset = job->common.len -

                         hbitmap_count(job->copy_bitmap) * job->cluster_size;

    /* TODO block_job_progress_set_remaining() would make more sense */

    block_job_progress_update(&job->common,

        job->len - hbitmap_count(job->copy_bitmap) * job->cluster_size);



    bdrv_dirty_iter_free(dbi);

}
@@ -437,7 +424,9 @@ static void coroutine_fn backup_run(void *opaque) 
    QLIST_INIT(&job->inflight_reqs);

    qemu_co_rwlock_init(&job->flush_rwlock);



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

    nb_clusters = DIV_ROUND_UP(job->len, job->cluster_size);

    block_job_progress_set_remaining(&job->common, job->len);



    job->copy_bitmap = hbitmap_alloc(nb_clusters, 0);

    if (job->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {

        backup_incremental_init_copy_bitmap(job);
@@ -461,7 +450,7 @@ static void coroutine_fn backup_run(void *opaque) 
        ret = backup_run_incremental(job);

    } else {

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

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

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

             offset += job->cluster_size) {

            bool error_is_read;

            int alloced = 0;
@@ -537,7 +526,6 @@ static const BlockJobDriver backup_job_driver = { 
    .instance_size          = sizeof(BackupBlockJob),

    .job_type               = BLOCK_JOB_TYPE_BACKUP,

    .start                  = backup_run,

    .set_speed              = backup_set_speed,

    .commit                 = backup_commit,

    .abort                  = backup_abort,

    .clean                  = backup_clean,
@@ -620,7 +608,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, 
        goto error;

    }



    /* job->common.len is fixed, so we can't allow resize */

    /* job->len is fixed, so we can't allow resize */

    job = block_job_create(job_id, &backup_job_driver, txn, bs,

                           BLK_PERM_CONSISTENT_READ,

                           BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE |
@@ -676,7 +664,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, 
    /* Required permissions are already taken with target's blk_new() */

    block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,

                       &error_abort);

    job->common.len = len;

    job->len = len;



    return &job->common;

block/blkdebug.c

+5 −4
Original line number Diff line number Diff line
@@ -398,10 +398,11 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 
        goto out;

    }



    bs->supported_write_flags = BDRV_REQ_FUA &

        bs->file->bs->supported_write_flags;

    bs->supported_zero_flags = (BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP) &

        bs->file->bs->supported_zero_flags;

    bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |

        (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);

    bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |

        ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP) &

            bs->file->bs->supported_zero_flags);

    ret = -EINVAL;



    /* Set alignment overrides */

block/blkreplay.c

+3 −0
Original line number Diff line number Diff line
@@ -35,6 +35,9 @@ static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags, 
        goto fail;

    }



    bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED;

    bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED;



    ret = 0;

fail:

    return ret;

block/blkverify.c

+3 −0
Original line number Diff line number Diff line
@@ -141,6 +141,9 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags, 
        goto fail;

    }



    bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED;

    bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED;



    ret = 0;

fail:

    qemu_opts_del(opts);