Commit debe40fb authored by Anthony Liguori's avatar Anthony Liguori
Browse files

Merge remote-tracking branch 'stefanha/block' into staging 



* stefanha/block:
  commit: Remove unused check
  qemu-iotests: Update test cases for commit active
  commit: Support commit active layer
  block: Add commit_active_start()
  mirror: Move base to MirrorBlockJob
  mirror: Don't close target
  qemu-iotests: drop duplicate virtio-blk initialization failure
  vmdk: Allow vmdk_create to work with protocol
  vmdk: Check VMFS extent line field number
  docs: updated qemu-img man page and qemu-doc to reflect VHDX support.
  block: vhdx - improve error message, and .bdrv_check implementation
  block/iscsi: Fix compilation for libiscsi 1.4.0 (API change)
  qapi-schema: fix QEMU 1.8 references
  dataplane: replace hostmem with memory_region_find
  dataplane: change vring API to use VirtQueueElement
  vring: factor common code for error exits
  vring: create a common function to parse descriptors
  sheepdog: fix dynamic grow for running qcow2 format

Message-id: 1387554416-5837-1-git-send-email-stefanha@redhat.com
Signed-off-by: default avatarAnthony Liguori <aliguori@amazon.com>
parents d1819762 18da7f94

block/commit.c

+1 −7
Original line number Diff line number Diff line
@@ -198,13 +198,7 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, 
        return;

    }



    /* Once we support top == active layer, remove this check */

    if (top == bs) {

        error_setg(errp,

                   "Top image as the active layer is currently unsupported");

        return;

    }



    assert(top != bs);

    if (top == base) {

        error_setg(errp, "Invalid files for merge: top and base are the same");

        return;

block/iscsi.c

+4 −1
Original line number Diff line number Diff line
@@ -359,7 +359,10 @@ retry: 
    default:

        iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba,

                                       num_sectors * iscsilun->block_size,

                                       iscsilun->block_size, 0, 0, 0, 0, 0,

                                       iscsilun->block_size,

#if !defined(CONFIG_LIBISCSI_1_4) /* API change from 1.4.0 to 1.5.0 */

                                       0, 0, 0, 0, 0,

#endif

                                       iscsi_co_generic_cb, &iTask);

        break;

    }

block/mirror.c

+65 −13
Original line number Diff line number Diff line
@@ -31,7 +31,8 @@ typedef struct MirrorBlockJob { 
    BlockJob common;

    RateLimit limit;

    BlockDriverState *target;

    MirrorSyncMode mode;

    BlockDriverState *base;

    bool is_none_mode;

    BlockdevOnError on_source_error, on_target_error;

    bool synced;

    bool should_complete;
@@ -335,10 +336,9 @@ static void coroutine_fn mirror_run(void *opaque) 
    sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;

    mirror_free_init(s);



    if (s->mode != MIRROR_SYNC_MODE_NONE) {

    if (!s->is_none_mode) {

        /* First part, loop on the sectors and initialize the dirty bitmap.  */

        BlockDriverState *base;

        base = s->mode == MIRROR_SYNC_MODE_FULL ? NULL : bs->backing_hd;

        BlockDriverState *base = s->base;

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

            int64_t next = (sector_num | (sectors_per_chunk - 1)) + 1;

            ret = bdrv_is_allocated_above(bs, base,
@@ -481,8 +481,14 @@ immediate_exit: 
            bdrv_reopen(s->target, bdrv_get_flags(s->common.bs), NULL);

        }

        bdrv_swap(s->target, s->common.bs);

        if (s->common.driver->job_type == BLOCK_JOB_TYPE_COMMIT) {

            /* drop the bs loop chain formed by the swap: break the loop then

             * trigger the unref from the top one */

            BlockDriverState *p = s->base->backing_hd;

            s->base->backing_hd = NULL;

            bdrv_unref(p);

        }

    }

    bdrv_close(s->target);

    bdrv_unref(s->target);

    block_job_completed(&s->common, ret);

}
@@ -536,12 +542,24 @@ static const BlockJobDriver mirror_job_driver = { 
    .complete      = mirror_complete,

};



void mirror_start(BlockDriverState *bs, BlockDriverState *target,

                  int64_t speed, int64_t granularity, int64_t buf_size,

                  MirrorSyncMode mode, BlockdevOnError on_source_error,

static const BlockJobDriver commit_active_job_driver = {

    .instance_size = sizeof(MirrorBlockJob),

    .job_type      = BLOCK_JOB_TYPE_COMMIT,

    .set_speed     = mirror_set_speed,

    .iostatus_reset

                   = mirror_iostatus_reset,

    .complete      = mirror_complete,

};



static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target,

                            int64_t speed, int64_t granularity,

                            int64_t buf_size,

                            BlockdevOnError on_source_error,

                            BlockdevOnError on_target_error,

                            BlockDriverCompletionFunc *cb,

                  void *opaque, Error **errp)

                            void *opaque, Error **errp,

                            const BlockJobDriver *driver,

                            bool is_none_mode, BlockDriverState *base)

{

    MirrorBlockJob *s;
@@ -566,7 +584,8 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, 
        return;

    }



    s = block_job_create(&mirror_job_driver, bs, speed, cb, opaque, errp);



    s = block_job_create(driver, bs, speed, cb, opaque, errp);

    if (!s) {

        return;

    }
@@ -574,7 +593,8 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, 
    s->on_source_error = on_source_error;

    s->on_target_error = on_target_error;

    s->target = target;

    s->mode = mode;

    s->is_none_mode = is_none_mode;

    s->base = base;

    s->granularity = granularity;

    s->buf_size = MAX(buf_size, granularity);
@@ -586,3 +606,35 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, 
    trace_mirror_start(bs, s, s->common.co, opaque);

    qemu_coroutine_enter(s->common.co, s);

}



void mirror_start(BlockDriverState *bs, BlockDriverState *target,

                  int64_t speed, int64_t granularity, int64_t buf_size,

                  MirrorSyncMode mode, BlockdevOnError on_source_error,

                  BlockdevOnError on_target_error,

                  BlockDriverCompletionFunc *cb,

                  void *opaque, Error **errp)

{

    bool is_none_mode;

    BlockDriverState *base;



    is_none_mode = mode == MIRROR_SYNC_MODE_NONE;

    base = mode == MIRROR_SYNC_MODE_TOP ? bs->backing_hd : NULL;

    mirror_start_job(bs, target, speed, granularity, buf_size,

                     on_source_error, on_target_error, cb, opaque, errp,

                     &mirror_job_driver, is_none_mode, base);

}



void commit_active_start(BlockDriverState *bs, BlockDriverState *base,

                         int64_t speed,

                         BlockdevOnError on_error,

                         BlockDriverCompletionFunc *cb,

                         void *opaque, Error **errp)

{

    if (bdrv_reopen(base, bs->open_flags, errp)) {

        return;

    }

    bdrv_ref(base);

    mirror_start_job(bs, base, speed, 0, 0,

                     on_error, on_error, cb, opaque, errp,

                     &commit_active_job_driver, false, base);

}

block/sheepdog.c

+4 −3
Original line number Diff line number Diff line
@@ -2048,13 +2048,14 @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num, 
{

    SheepdogAIOCB *acb;

    int ret;

    int64_t offset = (sector_num + nb_sectors) * BDRV_SECTOR_SIZE;

    BDRVSheepdogState *s = bs->opaque;



    if (bs->growable && sector_num + nb_sectors > bs->total_sectors) {

        ret = sd_truncate(bs, (sector_num + nb_sectors) * BDRV_SECTOR_SIZE);

    if (bs->growable && offset > s->inode.vdi_size) {

        ret = sd_truncate(bs, offset);

        if (ret < 0) {

            return ret;

        }

        bs->total_sectors = sector_num + nb_sectors;

    }



    acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);

block/vhdx-log.c

+12 −1
Original line number Diff line number Diff line
@@ -706,7 +706,8 @@ exit: 
 *

 * If read-only, we must replay the log in RAM (or refuse to open

 * a dirty VHDX file read-only) */

int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed)

int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed,

                   Error **errp)

{

    int ret = 0;

    VHDXHeader *hdr;
@@ -761,6 +762,16 @@ int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed) 
    }



    if (logs.valid) {

        if (bs->read_only) {

            ret = -EPERM;

            error_setg_errno(errp, EPERM,

                             "VHDX image file '%s' opened read-only, but "

                             "contains a log that needs to be replayed.  To "

                             "replay the log, execute:\n qemu-img check -r "

                             "all '%s'",

                             bs->filename, bs->filename);

            goto exit;

        }

        /* now flush the log */

        ret = vhdx_log_flush(bs, s, &logs);

        if (ret < 0) {