Commit 3b71ec85 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 Fri 23 Sep 2016 12:59:46 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: (33 commits)
  block: Remove BB interface from blockdev-add/del
  qemu-iotests/141: Avoid blockdev-add with id
  block: Avoid printing NULL string in error messages
  qemu-iotests/139: Avoid blockdev-add with id
  qemu-iotests/124: Avoid blockdev-add with id
  qemu-iotests/118: Avoid blockdev-add with id
  qemu-iotests/117: Avoid blockdev-add with id
  qemu-iotests/087: Avoid blockdev-add with id
  qemu-iotests/081: Avoid blockdev-add with id
  qemu-iotests/071: Avoid blockdev-add with id
  qemu-iotests/067: Avoid blockdev-add with id
  qemu-iotests/041: Avoid blockdev-add with id
  qemu-iotests/118: Test media change with qdev name
  block: Accept device model name for block_set_io_throttle
  block: Accept device model name for blockdev-change-medium
  block: Accept device model name for eject
  block: Accept device model name for x-blockdev-remove-medium
  block: Accept device model name for x-blockdev-insert-medium
  block: Accept device model name for blockdev-open/close-tray
  qdev-monitor: Add blk_by_qdev_id()
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents eaff9c43 9ec8873e

block.c

+65 −24
Original line number Diff line number Diff line
@@ -733,6 +733,9 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, 
    qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");

    qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");



    /* Copy the read-only option from the parent */

    qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);



    /* aio=native doesn't work for cache.direct=off, so disable it for the

     * temporary snapshot */

    *child_flags &= ~BDRV_O_NATIVE_AIO;
@@ -755,6 +758,9 @@ static void bdrv_inherited_options(int *child_flags, QDict *child_options, 
    qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);

    qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);



    /* Inherit the read-only option from the parent if it's not set */

    qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);



    /* Our block drivers take care to send flushes and respect unmap policy,

     * so we can default to enable both on lower layers regardless of the

     * corresponding parent options. */
@@ -808,7 +814,8 @@ static void bdrv_backing_options(int *child_flags, QDict *child_options, 
    qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);



    /* backing files always opened read-only */

    flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);

    qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");

    flags &= ~BDRV_O_COPY_ON_READ;



    /* snapshot=on is handled on the top layer */

    flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
@@ -855,6 +862,14 @@ static void update_flags_from_options(int *flags, QemuOpts *opts) 
    if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {

        *flags |= BDRV_O_NOCACHE;

    }



    *flags &= ~BDRV_O_RDWR;



    assert(qemu_opt_find(opts, BDRV_OPT_READ_ONLY));

    if (!qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false)) {

        *flags |= BDRV_O_RDWR;

    }



}



static void update_options_from_flags(QDict *options, int flags)
@@ -867,6 +882,10 @@ static void update_options_from_flags(QDict *options, int flags) 
        qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,

                  qbool_from_bool(flags & BDRV_O_NO_FLUSH));

    }

    if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {

        qdict_put(options, BDRV_OPT_READ_ONLY,

                  qbool_from_bool(!(flags & BDRV_O_RDWR)));

    }

}



static void bdrv_assign_node_name(BlockDriverState *bs,
@@ -930,6 +949,11 @@ static QemuOptsList bdrv_runtime_opts = { 
            .type = QEMU_OPT_BOOL,

            .help = "Ignore flush requests",

        },

        {

            .name = BDRV_OPT_READ_ONLY,

            .type = QEMU_OPT_BOOL,

            .help = "Node is opened in read-only mode",

        },

        { /* end of list */ }

    },

};
@@ -961,6 +985,8 @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file, 
        goto fail_opts;

    }



    update_flags_from_options(&bs->open_flags, opts);



    driver_name = qemu_opt_get(opts, "driver");

    drv = bdrv_find_format(driver_name);

    assert(drv != NULL);
@@ -1022,9 +1048,6 @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file, 
    bs->drv = drv;

    bs->opaque = g_malloc0(drv->instance_size);



    /* Apply cache mode options */

    update_flags_from_options(&bs->open_flags, opts);



    /* Open the image, either directly or using a protocol */

    open_flags = bdrv_open_flags(bs, bs->open_flags);

    if (drv->bdrv_file_open) {
@@ -1675,6 +1698,25 @@ static BlockDriverState *bdrv_open_inherit(const char *filename, 
        goto fail;

    }



    /* Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.

     * FIXME: we're parsing the QDict to avoid having to create a

     * QemuOpts just for this, but neither option is optimal. */

    if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&

        !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {

        flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);

    } else {

        flags &= ~BDRV_O_RDWR;

    }



    if (flags & BDRV_O_SNAPSHOT) {

        snapshot_options = qdict_new();

        bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,

                                   flags, options);

        /* Let bdrv_backing_options() override "read-only" */

        qdict_del(options, BDRV_OPT_READ_ONLY);

        bdrv_backing_options(&flags, options, flags, options);

    }



    bs->open_flags = flags;

    bs->options = options;

    options = qdict_clone_shallow(options);
@@ -1699,18 +1741,6 @@ static BlockDriverState *bdrv_open_inherit(const char *filename, 


    /* Open image file without format layer */

    if ((flags & BDRV_O_PROTOCOL) == 0) {

        if (flags & BDRV_O_RDWR) {

            flags |= BDRV_O_ALLOW_RDWR;

        }

        if (flags & BDRV_O_SNAPSHOT) {

            snapshot_options = qdict_new();

            bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,

                                       flags, options);

            bdrv_backing_options(&flags, options, flags, options);

        }



        bs->open_flags = flags;



        file = bdrv_open_child(filename, options, "file", bs,

                               &child_file, true, &local_err);

        if (local_err) {
@@ -1895,6 +1925,13 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, 
        options = qdict_new();

    }



    /* Check if this BlockDriverState is already in the queue */

    QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {

        if (bs == bs_entry->state.bs) {

            break;

        }

    }



    /*

     * Precedence of options:

     * 1. Explicitly passed in options (highest)
@@ -1915,7 +1952,11 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, 
    }



    /* Old explicitly set values (don't overwrite by inherited value) */

    if (bs_entry) {

        old_options = qdict_clone_shallow(bs_entry->state.explicit_options);

    } else {

        old_options = qdict_clone_shallow(bs->explicit_options);

    }

    bdrv_join_options(bs, options, old_options);

    QDECREF(old_options);
@@ -1954,8 +1995,13 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, 
                                child->role, options, flags);

    }



    if (!bs_entry) {

        bs_entry = g_new0(BlockReopenQueueEntry, 1);

        QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);

    } else {

        QDECREF(bs_entry->state.options);

        QDECREF(bs_entry->state.explicit_options);

    }



    bs_entry->state.bs = bs;

    bs_entry->state.options = options;
@@ -3013,11 +3059,6 @@ bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag) 
    return false;

}



int bdrv_is_snapshot(BlockDriverState *bs)

{

    return !!(bs->open_flags & BDRV_O_SNAPSHOT);

}



/* backing_file can either be relative, or absolute, or a protocol.  If it is

 * relative, it must be relative to the chain.  So, passing in bs->filename

 * from a BDS as backing_file should not be done, as that may be relative to

block/block-backend.c

+19 −0
Original line number Diff line number Diff line
@@ -559,6 +559,25 @@ void *blk_get_attached_dev(BlockBackend *blk) 
    return blk->dev;

}



/*

 * Return the BlockBackend which has the device model @dev attached if it

 * exists, else null.

 *

 * @dev must not be null.

 */

BlockBackend *blk_by_dev(void *dev)

{

    BlockBackend *blk = NULL;



    assert(dev != NULL);

    while ((blk = blk_all_next(blk)) != NULL) {

        if (blk->dev == dev) {

            return blk;

        }

    }

    return NULL;

}



/*

 * Set @blk's device model callbacks to @ops.

 * @opaque is the opaque argument to pass to the callbacks.

block/commit.c

+4 −4
Original line number Diff line number Diff line
@@ -242,14 +242,14 @@ void commit_start(const char *job_id, BlockDriverState *bs, 
    orig_overlay_flags = bdrv_get_flags(overlay_bs);



    /* convert base & overlay_bs to r/w, if necessary */

    if (!(orig_overlay_flags & BDRV_O_RDWR)) {

        reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs, NULL,

                                         orig_overlay_flags | BDRV_O_RDWR);

    }

    if (!(orig_base_flags & BDRV_O_RDWR)) {

        reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,

                                         orig_base_flags | BDRV_O_RDWR);

    }

    if (!(orig_overlay_flags & BDRV_O_RDWR)) {

        reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs, NULL,

                                         orig_overlay_flags | BDRV_O_RDWR);

    }

    if (reopen_queue) {

        bdrv_reopen_multiple(reopen_queue, &local_err);

        if (local_err != NULL) {

block/qcow2-cluster.c

+1 −1
Original line number Diff line number Diff line
@@ -429,7 +429,7 @@ static int coroutine_fn do_perform_cow(BlockDriverState *bs, 


    if (bs->encrypted) {

        Error *err = NULL;

        int64_t sector = (cluster_offset + offset_in_cluster)

        int64_t sector = (src_cluster_offset + offset_in_cluster)

                         >> BDRV_SECTOR_BITS;

        assert(s->cipher);

        assert((offset_in_cluster & ~BDRV_SECTOR_MASK) == 0);

block/vvfat.c

+2 −1
Original line number Diff line number Diff line
@@ -2971,7 +2971,8 @@ static BlockDriver vvfat_write_target = { 
static void vvfat_qcow_options(int *child_flags, QDict *child_options,

                               int parent_flags, QDict *parent_options)

{

    *child_flags = BDRV_O_RDWR | BDRV_O_NO_FLUSH;

    qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "off");

    *child_flags = BDRV_O_NO_FLUSH;

}



static const BdrvChildRole child_vvfat_qcow = {