Commit 2e020834 authored by Peter Maydell's avatar Peter Maydell
Browse files

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



Block layer patches for 2.11.0-rc2

# gpg: Signature made Fri 17 Nov 2017 17:58:36 GMT
# 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: (25 commits)
  iotests: Make 087 pass without AIO enabled
  block: Make bdrv_next() keep strong references
  qcow2: Fix overly broad madvise()
  qcow2: Refuse to get unaligned offsets from cache
  qcow2: Add bounds check to get_refblock_offset()
  block: Guard against NULL bs->drv
  qcow2: Unaligned zero cluster in handle_alloc()
  qcow2: check_errors are fatal
  qcow2: reject unaligned offsets in write compressed
  iotests: Add test for failing qemu-img commit
  tests: Add check-qobject for equality tests
  iotests: Add test for non-string option reopening
  block: qobject_is_equal() in bdrv_reopen_prepare()
  qapi: Add qobject_is_equal()
  qapi/qlist: Add qlist_append_null() macro
  qapi/qnull: Add own header
  qcow2: fix image corruption on commit with persistent bitmap
  iotests: test clearing unknown autoclear_features by qcow2
  block: Fix permissions in image activation
  qcow2: fix image corruption after committing qcow2 image into base
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 085ee6d2 d5a49c6e

block.c

+67 −23
Original line number Diff line number Diff line
@@ -261,6 +261,11 @@ int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, 
    return 0;

}



/* TODO Remove (deprecated since 2.11)

 * Block drivers are not supposed to automatically change bs->read_only.

 * Instead, they should just check whether they can provide what the user

 * explicitly requested and error out if read-write is requested, but they can

 * only provide read-only access. */

int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

{

    int ret = 0;
@@ -715,6 +720,10 @@ static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 
{

    BlockDriver *drv = bs->drv;



    if (!drv) {

        return -ENOMEDIUM;

    }



    /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */

    if (bdrv_is_sg(bs))

        return 0;
@@ -998,7 +1007,7 @@ static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base, 
    ret = bdrv_change_backing_file(parent, filename,

                                   base->drv ? base->drv->format_name : "");

    if (ret < 0) {

        error_setg_errno(errp, ret, "Could not update backing file link");

        error_setg_errno(errp, -ret, "Could not update backing file link");

    }



    if (!(orig_flags & BDRV_O_RDWR)) {
@@ -3069,19 +3078,26 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, 
        const QDictEntry *entry = qdict_first(reopen_state->options);



        do {

            QString *new_obj = qobject_to_qstring(entry->value);

            const char *new = qstring_get_str(new_obj);

            QObject *new = entry->value;

            QObject *old = qdict_get(reopen_state->bs->options, entry->key);



            /*

             * Caution: while qdict_get_try_str() is fine, getting

             * non-string types would require more care.  When

             * bs->options come from -blockdev or blockdev_add, its

             * members are typed according to the QAPI schema, but

             * when they come from -drive, they're all QString.

             * TODO: When using -drive to specify blockdev options, all values

             * will be strings; however, when using -blockdev, blockdev-add or

             * filenames using the json:{} pseudo-protocol, they will be

             * correctly typed.

             * In contrast, reopening options are (currently) always strings

             * (because you can only specify them through qemu-io; all other

             * callers do not specify any options).

             * Therefore, when using anything other than -drive to create a BDS,

             * this cannot detect non-string options as unchanged, because

             * qobject_is_equal() always returns false for objects of different

             * type.  In the future, this should be remedied by correctly typing

             * all options.  For now, this is not too big of an issue because

             * the user can simply omit options which cannot be changed anyway,

             * so they will stay unchanged.

             */

            const char *old = qdict_get_try_str(reopen_state->bs->options,

                                                entry->key);



            if (!old || strcmp(new, old)) {

            if (!qobject_is_equal(new, old)) {

                error_setg(errp, "Cannot change the option '%s'", entry->key);

                ret = -EINVAL;

                goto error;
@@ -3419,6 +3435,10 @@ int bdrv_change_backing_file(BlockDriverState *bs, 
    BlockDriver *drv = bs->drv;

    int ret;



    if (!drv) {

        return -ENOMEDIUM;

    }



    /* Backing file format doesn't make sense without a backing file */

    if (backing_fmt && !backing_file) {

        return -EINVAL;
@@ -3904,7 +3924,9 @@ int bdrv_has_zero_init_1(BlockDriverState *bs) 


int bdrv_has_zero_init(BlockDriverState *bs)

{

    assert(bs->drv);

    if (!bs->drv) {

        return 0;

    }



    /* If BS is a copy on write image, it is initialized to

       the contents of the base image, which may not be zeroes.  */
@@ -4169,7 +4191,29 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 
        }

    }



    /*

     * Update permissions, they may differ for inactive nodes.

     *

     * Note that the required permissions of inactive images are always a

     * subset of the permissions required after activating the image. This

     * allows us to just get the permissions upfront without restricting

     * drv->bdrv_invalidate_cache().

     *

     * It also means that in error cases, we don't have to try and revert to

     * the old permissions (which is an operation that could fail, too). We can

     * just keep the extended permissions for the next time that an activation

     * of the image is tried.

     */

    bs->open_flags &= ~BDRV_O_INACTIVE;

    bdrv_get_cumulative_perm(bs, &perm, &shared_perm);

    ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);

    if (ret < 0) {

        bs->open_flags |= BDRV_O_INACTIVE;

        error_propagate(errp, local_err);

        return;

    }

    bdrv_set_perm(bs, perm, shared_perm);



    if (bs->drv->bdrv_invalidate_cache) {

        bs->drv->bdrv_invalidate_cache(bs, &local_err);

        if (local_err) {
@@ -4186,16 +4230,6 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 
        return;

    }



    /* Update permissions, they may differ for inactive nodes */

    bdrv_get_cumulative_perm(bs, &perm, &shared_perm);

    ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);

    if (ret < 0) {

        bs->open_flags |= BDRV_O_INACTIVE;

        error_propagate(errp, local_err);

        return;

    }

    bdrv_set_perm(bs, perm, shared_perm);



    QLIST_FOREACH(parent, &bs->parents, next_parent) {

        if (parent->role->activate) {

            parent->role->activate(parent, &local_err);
@@ -4221,6 +4255,7 @@ void bdrv_invalidate_cache_all(Error **errp) 
        aio_context_release(aio_context);

        if (local_err) {

            error_propagate(errp, local_err);

            bdrv_next_cleanup(&it);

            return;

        }

    }
@@ -4232,6 +4267,10 @@ static int bdrv_inactivate_recurse(BlockDriverState *bs, 
    BdrvChild *child, *parent;

    int ret;



    if (!bs->drv) {

        return -ENOMEDIUM;

    }



    if (!setting_flag && bs->drv->bdrv_inactivate) {

        ret = bs->drv->bdrv_inactivate(bs);

        if (ret < 0) {
@@ -4292,6 +4331,7 @@ int bdrv_inactivate_all(void) 
        for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {

            ret = bdrv_inactivate_recurse(bs, pass);

            if (ret < 0) {

                bdrv_next_cleanup(&it);

                goto out;

            }

        }
@@ -4766,6 +4806,9 @@ void bdrv_remove_aio_context_notifier(BlockDriverState *bs, 
int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,

                       BlockDriverAmendStatusCB *status_cb, void *cb_opaque)

{

    if (!bs->drv) {

        return -ENOMEDIUM;

    }

    if (!bs->drv->bdrv_amend_options) {

        return -ENOTSUP;

    }
@@ -4823,6 +4866,7 @@ bool bdrv_is_first_non_filter(BlockDriverState *candidate) 


        /* candidate is the first non filter */

        if (perm) {

            bdrv_next_cleanup(&it);

            return true;

        }

    }

block/block-backend.c

+46 −2
Original line number Diff line number Diff line
@@ -442,21 +442,37 @@ BlockBackend *blk_next(BlockBackend *blk) 
 * the monitor or attached to a BlockBackend */

BlockDriverState *bdrv_next(BdrvNextIterator *it)

{

    BlockDriverState *bs;

    BlockDriverState *bs, *old_bs;



    /* Must be called from the main loop */

    assert(qemu_get_current_aio_context() == qemu_get_aio_context());



    /* First, return all root nodes of BlockBackends. In order to avoid

     * returning a BDS twice when multiple BBs refer to it, we only return it

     * if the BB is the first one in the parent list of the BDS. */

    if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {

        BlockBackend *old_blk = it->blk;



        old_bs = old_blk ? blk_bs(old_blk) : NULL;



        do {

            it->blk = blk_all_next(it->blk);

            bs = it->blk ? blk_bs(it->blk) : NULL;

        } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));



        if (it->blk) {

            blk_ref(it->blk);

        }

        blk_unref(old_blk);



        if (bs) {

            bdrv_ref(bs);

            bdrv_unref(old_bs);

            return bs;

        }

        it->phase = BDRV_NEXT_MONITOR_OWNED;

    } else {

        old_bs = it->bs;

    }



    /* Then return the monitor-owned BDSes without a BB attached. Ignore all
@@ -467,18 +483,46 @@ BlockDriverState *bdrv_next(BdrvNextIterator *it) 
        bs = it->bs;

    } while (bs && bdrv_has_blk(bs));



    if (bs) {

        bdrv_ref(bs);

    }

    bdrv_unref(old_bs);



    return bs;

}



BlockDriverState *bdrv_first(BdrvNextIterator *it)

static void bdrv_next_reset(BdrvNextIterator *it)

{

    *it = (BdrvNextIterator) {

        .phase = BDRV_NEXT_BACKEND_ROOTS,

    };

}



BlockDriverState *bdrv_first(BdrvNextIterator *it)

{

    bdrv_next_reset(it);

    return bdrv_next(it);

}



/* Must be called when aborting a bdrv_next() iteration before

 * bdrv_next() returns NULL */

void bdrv_next_cleanup(BdrvNextIterator *it)

{

    /* Must be called from the main loop */

    assert(qemu_get_current_aio_context() == qemu_get_aio_context());



    if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {

        if (it->blk) {

            bdrv_unref(blk_bs(it->blk));

            blk_unref(it->blk);

        }

    } else {

        bdrv_unref(it->bs);

    }



    bdrv_next_reset(it);

}



/*

 * Add a BlockBackend into the list of backends referenced by the monitor, with

 * the given @name acting as the handle for the monitor.

block/bochs.c

+10 −3
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#include "block/block_int.h"

#include "qemu/module.h"

#include "qemu/bswap.h"

#include "qemu/error-report.h"



/**************************************************************/
@@ -110,10 +111,16 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, 
        return -EINVAL;

    }



    if (!bdrv_is_read_only(bs)) {

        error_report("Opening bochs images without an explicit read-only=on "

                     "option is deprecated. Future versions will refuse to "

                     "open the image instead of automatically marking the "

                     "image read-only.");

        ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */

        if (ret < 0) {

            return ret;

        }

    }



    ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));

    if (ret < 0) {

block/cloop.c

+10 −3
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
 */

#include "qemu/osdep.h"

#include "qapi/error.h"

#include "qemu/error-report.h"

#include "qemu-common.h"

#include "block/block_int.h"

#include "qemu/module.h"
@@ -72,10 +73,16 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, 
        return -EINVAL;

    }



    if (!bdrv_is_read_only(bs)) {

        error_report("Opening cloop images without an explicit read-only=on "

                     "option is deprecated. Future versions will refuse to "

                     "open the image instead of automatically marking the "

                     "image read-only.");

        ret = bdrv_set_read_only(bs, true, errp);

        if (ret < 0) {

            return ret;

        }

    }



    /* read header */

    ret = bdrv_pread(bs->file, 128, &s->block_size, 4);

block/dmg.c

+9 −3
Original line number Diff line number Diff line
@@ -419,10 +419,16 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, 
        return -EINVAL;

    }



    if (!bdrv_is_read_only(bs)) {

        error_report("Opening dmg images without an explicit read-only=on "

                     "option is deprecated. Future versions will refuse to "

                     "open the image instead of automatically marking the "

                     "image read-only.");

        ret = bdrv_set_read_only(bs, true, errp);

        if (ret < 0) {

            return ret;

        }

    }



    block_module_load_one("dmg-bz2");