Commit fc7dbc11 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 Tue 21 Nov 2017 15:09:12 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:
  iotests: Fix 176 on 32-bit host
  block: Close a BlockDriverState completely even when bs->drv is NULL
  block: Error out on load_vm with active dirty bitmaps
  block: Add errp to bdrv_all_goto_snapshot()
  block: Add errp to bdrv_snapshot_goto()
  block: Don't request I/O permission with BDRV_O_NO_IO
  block: Don't use BLK_PERM_CONSISTENT_READ for format probing

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 7c3d1917 4fd0295c

block.c

+32 −30
Original line number Diff line number Diff line
@@ -2579,7 +2579,10 @@ static BlockDriverState *bdrv_open_inherit(const char *filename, 
            goto fail;

        }

        if (file_bs != NULL) {

            file = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);

            /* Not requesting BLK_PERM_CONSISTENT_READ because we're only

             * looking at the header to guess the image format. This works even

             * in cases where a guest would not see a consistent state. */

            file = blk_new(0, BLK_PERM_ALL);

            blk_insert_bs(file, file_bs, &local_err);

            bdrv_unref(file_bs);

            if (local_err) {
@@ -3195,6 +3198,7 @@ void bdrv_reopen_abort(BDRVReopenState *reopen_state) 
static void bdrv_close(BlockDriverState *bs)

{

    BdrvAioNotifier *ban, *ban_next;

    BdrvChild *child, *next;



    assert(!bs->job);

    assert(!bs->refcnt);
@@ -3204,10 +3208,9 @@ static void bdrv_close(BlockDriverState *bs) 
    bdrv_drain(bs); /* in case flush left pending I/O */



    if (bs->drv) {

        BdrvChild *child, *next;



        bs->drv->bdrv_close(bs);

        bs->drv = NULL;

    }



    bdrv_set_backing_hd(bs, NULL, &error_abort);
@@ -3239,7 +3242,6 @@ static void bdrv_close(BlockDriverState *bs) 
    bs->explicit_options = NULL;

    QDECREF(bs->full_open_options);

    bs->full_open_options = NULL;

    }



    bdrv_release_named_dirty_bitmaps(bs);

    assert(QLIST_EMPTY(&bs->dirty_bitmaps));

block/block-backend.c

+6 −4
Original line number Diff line number Diff line
@@ -299,7 +299,7 @@ BlockBackend *blk_new_open(const char *filename, const char *reference, 
{

    BlockBackend *blk;

    BlockDriverState *bs;

    uint64_t perm;

    uint64_t perm = 0;



    /* blk_new_open() is mainly used in .bdrv_create implementations and the

     * tools where sharing isn't a concern because the BDS stays private, so we
@@ -309,10 +309,12 @@ BlockBackend *blk_new_open(const char *filename, const char *reference, 
     * caller of blk_new_open() doesn't make use of the permissions, but they

     * shouldn't hurt either. We can still share everything here because the

     * guest devices will add their own blockers if they can't share. */

    perm = BLK_PERM_CONSISTENT_READ;

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

        perm |= BLK_PERM_CONSISTENT_READ;

        if (flags & BDRV_O_RDWR) {

            perm |= BLK_PERM_WRITE;

        }

    }

    if (flags & BDRV_O_RESIZE) {

        perm |= BLK_PERM_RESIZE;

    }

block/snapshot.c

+24 −21
Original line number Diff line number Diff line
@@ -177,36 +177,35 @@ int bdrv_snapshot_create(BlockDriverState *bs, 
}



int bdrv_snapshot_goto(BlockDriverState *bs,

                       const char *snapshot_id)

                       const char *snapshot_id,

                       Error **errp)

{

    BlockDriver *drv = bs->drv;

    int ret, open_ret;

    int64_t len;



    if (!drv) {

        error_setg(errp, "Block driver is closed");

        return -ENOMEDIUM;

    }



    len = bdrv_getlength(bs);

    if (len < 0) {

        return len;

    if (!QLIST_EMPTY(&bs->dirty_bitmaps)) {

        error_setg(errp, "Device has active dirty bitmaps");

        return -EBUSY;

    }

    /* We should set all bits in all enabled dirty bitmaps, because dirty

     * bitmaps reflect active state of disk and snapshot switch operation

     * actually dirties active state.

     * TODO: It may make sense not to set all bits but analyze block status of

     * current state and destination snapshot and do not set bits corresponding

     * to both-zero or both-unallocated areas. */

    bdrv_set_dirty(bs, 0, len);



    if (drv->bdrv_snapshot_goto) {

        return drv->bdrv_snapshot_goto(bs, snapshot_id);

        ret = drv->bdrv_snapshot_goto(bs, snapshot_id);

        if (ret < 0) {

            error_setg_errno(errp, -ret, "Failed to load snapshot");

        }

        return ret;

    }



    if (bs->file) {

        BlockDriverState *file;

        QDict *options = qdict_clone_shallow(bs->options);

        QDict *file_options;

        Error *local_err = NULL;



        file = bs->file->bs;

        /* Prevent it from getting deleted when detached from bs */
@@ -220,13 +219,15 @@ int bdrv_snapshot_goto(BlockDriverState *bs, 
        bdrv_unref_child(bs, bs->file);

        bs->file = NULL;



        ret = bdrv_snapshot_goto(file, snapshot_id);

        open_ret = drv->bdrv_open(bs, options, bs->open_flags, NULL);

        ret = bdrv_snapshot_goto(file, snapshot_id, errp);

        open_ret = drv->bdrv_open(bs, options, bs->open_flags, &local_err);

        QDECREF(options);

        if (open_ret < 0) {

            bdrv_unref(file);

            bs->drv = NULL;

            return open_ret;

            /* A bdrv_snapshot_goto() error takes precedence */

            error_propagate(errp, local_err);

            return ret < 0 ? ret : open_ret;

        }



        assert(bs->file->bs == file);
@@ -234,6 +235,7 @@ int bdrv_snapshot_goto(BlockDriverState *bs, 
        return ret;

    }



    error_setg(errp, "Block driver does not support snapshots");

    return -ENOTSUP;

}
@@ -456,9 +458,10 @@ fail: 
}





int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs)

int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs,

                           Error **errp)

{

    int err = 0;

    int ret = 0;

    BlockDriverState *bs;

    BdrvNextIterator it;
@@ -467,10 +470,10 @@ int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs) 


        aio_context_acquire(ctx);

        if (bdrv_can_snapshot(bs)) {

            err = bdrv_snapshot_goto(bs, name);

            ret = bdrv_snapshot_goto(bs, name, errp);

        }

        aio_context_release(ctx);

        if (err < 0) {

        if (ret < 0) {

            bdrv_next_cleanup(&it);

            goto fail;

        }
@@ -478,7 +481,7 @@ int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs) 


fail:

    *first_bad_bs = bs;

    return err;

    return ret;

}



int bdrv_all_find_snapshot(const char *name, BlockDriverState **first_bad_bs)

include/block/snapshot.h

+4 −2
Original line number Diff line number Diff line
@@ -57,7 +57,8 @@ int bdrv_can_snapshot(BlockDriverState *bs); 
int bdrv_snapshot_create(BlockDriverState *bs,

                         QEMUSnapshotInfo *sn_info);

int bdrv_snapshot_goto(BlockDriverState *bs,

                       const char *snapshot_id);

                       const char *snapshot_id,

                       Error **errp);

int bdrv_snapshot_delete(BlockDriverState *bs,

                         const char *snapshot_id,

                         const char *name,
@@ -83,7 +84,8 @@ int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs, 
bool bdrv_all_can_snapshot(BlockDriverState **first_bad_bs);

int bdrv_all_delete_snapshot(const char *name, BlockDriverState **first_bsd_bs,

                             Error **err);

int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bsd_bs);

int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs,

                           Error **errp);

int bdrv_all_find_snapshot(const char *name, BlockDriverState **first_bad_bs);

int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn,

                             BlockDriverState *vm_state_bs,

migration/savevm.c

+3 −3
Original line number Diff line number Diff line
@@ -2346,10 +2346,10 @@ int load_snapshot(const char *name, Error **errp) 
    /* Flush all IO requests so they don't interfere with the new state.  */

    bdrv_drain_all_begin();



    ret = bdrv_all_goto_snapshot(name, &bs);

    ret = bdrv_all_goto_snapshot(name, &bs, errp);

    if (ret < 0) {

        error_setg(errp, "Error %d while activating snapshot '%s' on '%s'",

                     ret, name, bdrv_get_device_name(bs));

        error_prepend(errp, "Could not load snapshot '%s' on '%s': ",

                      name, bdrv_get_device_name(bs));

        goto err_drain;

    }