Commit c737c7a6 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 16 Oct 2015 14:36:50 BST using RSA key ID C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"

* remotes/kevin/tags/for-upstream: (29 commits)
  blkdebug: Don't confuse image as backing file
  qcow2: Remove forward declaration of QCowAIOCB
  qemu-nbd: always compile in --aio=MODE option
  blockdev: always compile in -drive aio= parsing
  raw-posix: warn about BDRV_O_NATIVE_AIO if libaio is unavailable
  block: auto-generated node-names
  util - add automated ID generation utility
  blkverify: Fix BDS leak in .bdrv_open error path
  block: Allow bdrv_unref_child(bs, NULL)
  block: Remove bdrv_swap()
  block: Add and use bdrv_replace_in_backing_chain()
  blockjob: Store device name at job creation
  block: Implement bdrv_append() without bdrv_swap()
  block: Introduce parents list
  block-backend: Add blk_set_bs()
  block/io: Make bdrv_requests_pending() public
  block: Split bdrv_move_feature_fields()
  block: Manage backing file references in bdrv_set_backing_hd()
  block: Convert bs->backing_hd to BdrvChild
  block: Remove bdrv_open_image()
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 6d57410a 6b826af7

block.c

+204 −308

File changed.

Preview size limit exceeded, changes collapsed.

block/blkdebug.c

+18 −16
Original line number Diff line number Diff line
@@ -426,11 +426,11 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 
    /* Set initial state */

    s->state = 1;



    /* Open the backing file */

    assert(bs->file == NULL);

    ret = bdrv_open_image(&bs->file, qemu_opt_get(opts, "x-image"), options, "image",

    /* Open the image file */

    bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image",

                               bs, &child_file, false, &local_err);

    if (ret < 0) {

    if (local_err) {

        ret = -EINVAL;

        error_propagate(errp, local_err);

        goto out;

    }
@@ -449,7 +449,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 
    goto out;



fail_unref:

    bdrv_unref(bs->file);

    bdrv_unref_child(bs, bs->file);

out:

    qemu_opts_del(opts);

    return ret;
@@ -510,7 +510,8 @@ static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs, 
        return inject_error(bs, cb, opaque, rule);

    }



    return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque);

    return bdrv_aio_readv(bs->file->bs, sector_num, qiov, nb_sectors,

                          cb, opaque);

}



static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs,
@@ -532,7 +533,8 @@ static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs, 
        return inject_error(bs, cb, opaque, rule);

    }



    return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque);

    return bdrv_aio_writev(bs->file->bs, sector_num, qiov, nb_sectors,

                           cb, opaque);

}



static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs,
@@ -551,7 +553,7 @@ static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs, 
        return inject_error(bs, cb, opaque, rule);

    }



    return bdrv_aio_flush(bs->file, cb, opaque);

    return bdrv_aio_flush(bs->file->bs, cb, opaque);

}
@@ -716,12 +718,12 @@ static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag) 


static int64_t blkdebug_getlength(BlockDriverState *bs)

{

    return bdrv_getlength(bs->file);

    return bdrv_getlength(bs->file->bs);

}



static int blkdebug_truncate(BlockDriverState *bs, int64_t offset)

{

    return bdrv_truncate(bs->file, offset);

    return bdrv_truncate(bs->file->bs, offset);

}



static void blkdebug_refresh_filename(BlockDriverState *bs)
@@ -741,24 +743,24 @@ static void blkdebug_refresh_filename(BlockDriverState *bs) 
        }

    }



    if (force_json && !bs->file->full_open_options) {

    if (force_json && !bs->file->bs->full_open_options) {

        /* The config file cannot be recreated, so creating a plain filename

         * is impossible */

        return;

    }



    if (!force_json && bs->file->exact_filename[0]) {

    if (!force_json && bs->file->bs->exact_filename[0]) {

        snprintf(bs->exact_filename, sizeof(bs->exact_filename),

                 "blkdebug:%s:%s",

                 qdict_get_try_str(bs->options, "config") ?: "",

                 bs->file->exact_filename);

                 bs->file->bs->exact_filename);

    }



    opts = qdict_new();

    qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkdebug")));



    QINCREF(bs->file->full_open_options);

    qdict_put_obj(opts, "image", QOBJECT(bs->file->full_open_options));

    QINCREF(bs->file->bs->full_open_options);

    qdict_put_obj(opts, "image", QOBJECT(bs->file->bs->full_open_options));



    for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {

        if (strcmp(qdict_entry_key(e), "x-image") &&

block/blkverify.c

+40 −31
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
#include "qapi/qmp/qstring.h"



typedef struct {

    BlockDriverState *test_file;

    BdrvChild *test_file;

} BDRVBlkverifyState;



typedef struct BlkverifyAIOCB BlkverifyAIOCB;
@@ -123,26 +123,29 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags, 
    }



    /* Open the raw file */

    assert(bs->file == NULL);

    ret = bdrv_open_image(&bs->file, qemu_opt_get(opts, "x-raw"), options,

                          "raw", bs, &child_file, false, &local_err);

    if (ret < 0) {

    bs->file = bdrv_open_child(qemu_opt_get(opts, "x-raw"), options, "raw",

                               bs, &child_file, false, &local_err);

    if (local_err) {

        ret = -EINVAL;

        error_propagate(errp, local_err);

        goto fail;

    }



    /* Open the test file */

    assert(s->test_file == NULL);

    ret = bdrv_open_image(&s->test_file, qemu_opt_get(opts, "x-image"), options,

                          "test", bs, &child_format, false, &local_err);

    if (ret < 0) {

    s->test_file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options,

                                   "test", bs, &child_format, false,

                                   &local_err);

    if (local_err) {

        ret = -EINVAL;

        error_propagate(errp, local_err);

        s->test_file = NULL;

        goto fail;

    }



    ret = 0;

fail:

    if (ret < 0) {

        bdrv_unref_child(bs, bs->file);

    }

    qemu_opts_del(opts);

    return ret;

}
@@ -151,7 +154,7 @@ static void blkverify_close(BlockDriverState *bs) 
{

    BDRVBlkverifyState *s = bs->opaque;



    bdrv_unref(s->test_file);

    bdrv_unref_child(bs, s->test_file);

    s->test_file = NULL;

}
@@ -159,7 +162,7 @@ static int64_t blkverify_getlength(BlockDriverState *bs) 
{

    BDRVBlkverifyState *s = bs->opaque;



    return bdrv_getlength(s->test_file);

    return bdrv_getlength(s->test_file->bs);

}



static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write,
@@ -238,13 +241,13 @@ static BlockAIOCB *blkverify_aio_readv(BlockDriverState *bs, 
                                            nb_sectors, cb, opaque);



    acb->verify = blkverify_verify_readv;

    acb->buf = qemu_blockalign(bs->file, qiov->size);

    acb->buf = qemu_blockalign(bs->file->bs, qiov->size);

    qemu_iovec_init(&acb->raw_qiov, acb->qiov->niov);

    qemu_iovec_clone(&acb->raw_qiov, qiov, acb->buf);



    bdrv_aio_readv(s->test_file, sector_num, qiov, nb_sectors,

    bdrv_aio_readv(s->test_file->bs, sector_num, qiov, nb_sectors,

                   blkverify_aio_cb, acb);

    bdrv_aio_readv(bs->file, sector_num, &acb->raw_qiov, nb_sectors,

    bdrv_aio_readv(bs->file->bs, sector_num, &acb->raw_qiov, nb_sectors,

                   blkverify_aio_cb, acb);

    return &acb->common;

}
@@ -257,9 +260,9 @@ static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs, 
    BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov,

                                            nb_sectors, cb, opaque);



    bdrv_aio_writev(s->test_file, sector_num, qiov, nb_sectors,

    bdrv_aio_writev(s->test_file->bs, sector_num, qiov, nb_sectors,

                    blkverify_aio_cb, acb);

    bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors,

    bdrv_aio_writev(bs->file->bs, sector_num, qiov, nb_sectors,

                    blkverify_aio_cb, acb);

    return &acb->common;

}
@@ -271,7 +274,7 @@ static BlockAIOCB *blkverify_aio_flush(BlockDriverState *bs, 
    BDRVBlkverifyState *s = bs->opaque;



    /* Only flush test file, the raw file is not important */

    return bdrv_aio_flush(s->test_file, cb, opaque);

    return bdrv_aio_flush(s->test_file->bs, cb, opaque);

}



static bool blkverify_recurse_is_first_non_filter(BlockDriverState *bs,
@@ -279,13 +282,13 @@ static bool blkverify_recurse_is_first_non_filter(BlockDriverState *bs, 
{

    BDRVBlkverifyState *s = bs->opaque;



    bool perm = bdrv_recurse_is_first_non_filter(bs->file, candidate);

    bool perm = bdrv_recurse_is_first_non_filter(bs->file->bs, candidate);



    if (perm) {

        return true;

    }



    return bdrv_recurse_is_first_non_filter(s->test_file, candidate);

    return bdrv_recurse_is_first_non_filter(s->test_file->bs, candidate);

}



/* Propagate AioContext changes to ->test_file */
@@ -293,7 +296,7 @@ static void blkverify_detach_aio_context(BlockDriverState *bs) 
{

    BDRVBlkverifyState *s = bs->opaque;



    bdrv_detach_aio_context(s->test_file);

    bdrv_detach_aio_context(s->test_file->bs);

}



static void blkverify_attach_aio_context(BlockDriverState *bs,
@@ -301,32 +304,38 @@ static void blkverify_attach_aio_context(BlockDriverState *bs, 
{

    BDRVBlkverifyState *s = bs->opaque;



    bdrv_attach_aio_context(s->test_file, new_context);

    bdrv_attach_aio_context(s->test_file->bs, new_context);

}



static void blkverify_refresh_filename(BlockDriverState *bs)

{

    BDRVBlkverifyState *s = bs->opaque;



    /* bs->file has already been refreshed */

    bdrv_refresh_filename(s->test_file);

    /* bs->file->bs has already been refreshed */

    bdrv_refresh_filename(s->test_file->bs);



    if (bs->file->full_open_options && s->test_file->full_open_options) {

    if (bs->file->bs->full_open_options

        && s->test_file->bs->full_open_options)

    {

        QDict *opts = qdict_new();

        qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkverify")));



        QINCREF(bs->file->full_open_options);

        qdict_put_obj(opts, "raw", QOBJECT(bs->file->full_open_options));

        QINCREF(s->test_file->full_open_options);

        qdict_put_obj(opts, "test", QOBJECT(s->test_file->full_open_options));

        QINCREF(bs->file->bs->full_open_options);

        qdict_put_obj(opts, "raw", QOBJECT(bs->file->bs->full_open_options));

        QINCREF(s->test_file->bs->full_open_options);

        qdict_put_obj(opts, "test",

                      QOBJECT(s->test_file->bs->full_open_options));



        bs->full_open_options = opts;

    }



    if (bs->file->exact_filename[0] && s->test_file->exact_filename[0]) {

    if (bs->file->bs->exact_filename[0]

        && s->test_file->bs->exact_filename[0])

    {

        snprintf(bs->exact_filename, sizeof(bs->exact_filename),

                 "blkverify:%s:%s",

                 bs->file->exact_filename, s->test_file->exact_filename);

                 bs->file->bs->exact_filename,

                 s->test_file->bs->exact_filename);

    }

}

block/block-backend.c

+17 −0
Original line number Diff line number Diff line
@@ -238,6 +238,23 @@ BlockDriverState *blk_bs(BlockBackend *blk) 
    return blk->bs;

}



/*

 * Changes the BlockDriverState attached to @blk

 */

void blk_set_bs(BlockBackend *blk, BlockDriverState *bs)

{

    bdrv_ref(bs);



    if (blk->bs) {

        blk->bs->blk = NULL;

        bdrv_unref(blk->bs);

    }

    assert(bs->blk == NULL);



    blk->bs = bs;

    bs->blk = blk;

}



/*

 * Return @blk's DriveInfo if any, else null.

 */

block/bochs.c

+4 −4
Original line number Diff line number Diff line
@@ -103,7 +103,7 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, 


    bs->read_only = 1; // no write support yet



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

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

    if (ret < 0) {

        return ret;

    }
@@ -137,7 +137,7 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, 
        return -ENOMEM;

    }



    ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap,

    ret = bdrv_pread(bs->file->bs, le32_to_cpu(bochs.header), s->catalog_bitmap,

                     s->catalog_size * 4);

    if (ret < 0) {

        goto fail;
@@ -206,7 +206,7 @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num) 
        (s->extent_blocks + s->bitmap_blocks));



    /* read in bitmap for current extent */

    ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8),

    ret = bdrv_pread(bs->file->bs, bitmap_offset + (extent_offset / 8),

                     &bitmap_entry, 1);

    if (ret < 0) {

        return ret;
@@ -229,7 +229,7 @@ static int bochs_read(BlockDriverState *bs, int64_t sector_num, 
        if (block_offset < 0) {

            return block_offset;

        } else if (block_offset > 0) {

            ret = bdrv_pread(bs->file, block_offset, buf, 512);

            ret = bdrv_pread(bs->file->bs, block_offset, buf, 512);

            if (ret < 0) {

                return ret;

            }