Commit 9a4f4c31 authored by Kevin Wolf's avatar Kevin Wolf
Browse files

block: Convert bs->file to BdrvChild 



This patch removes the temporary duplication between bs->file and
bs->file_child by converting everything to BdrvChild.

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
Reviewed-by: default avatarAlberto Garcia <berto@igalia.com>
Reviewed-by: default avatarFam Zheng <famz@redhat.com>
Reviewed-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
parent 0bd6e91a

block.c

+30 −33
Original line number Diff line number Diff line
@@ -809,7 +809,7 @@ static QemuOptsList bdrv_runtime_opts = { 
 *

 * Removes all processed options from *options.

 */

static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,

static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,

    QDict *options, int flags, BlockDriver *drv, Error **errp)

{

    int ret, open_flags;
@@ -823,7 +823,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, 
    assert(options != NULL && bs->options != options);



    if (file != NULL) {

        filename = file->filename;

        filename = file->bs->filename;

    } else {

        filename = qdict_get_try_str(options, "filename");

    }
@@ -1401,7 +1401,8 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 
                             const BdrvChildRole *child_role, Error **errp)

{

    int ret;

    BlockDriverState *file = NULL, *bs;

    BdrvChild *file = NULL;

    BlockDriverState *bs;

    BlockDriver *drv = NULL;

    const char *drvname;

    Error *local_err = NULL;
@@ -1485,25 +1486,20 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 
            flags = bdrv_backing_flags(flags);

        }



        assert(file == NULL);

        bs->open_flags = flags;



        bs->file_child = bdrv_open_child(filename, options, "file", bs,

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

                               &child_file, true, &local_err);

        if (local_err) {

            ret = -EINVAL;

            goto fail;

        }



        if (bs->file_child) {

            file = bs->file_child->bs;

        }

    }



    /* Image format probing */

    bs->probed = !drv;

    if (!drv && file) {

        ret = find_image_format(file, filename, &drv, &local_err);

        ret = find_image_format(file->bs, filename, &drv, &local_err);

        if (ret < 0) {

            goto fail;

        }
@@ -1526,7 +1522,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 
    }



    if (file && (bs->file != file)) {

        bdrv_unref(file);

        bdrv_unref_child(bs, file);

        file = NULL;

    }
@@ -1587,7 +1583,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 


fail:

    if (file != NULL) {

        bdrv_unref(file);

        bdrv_unref_child(bs, file);

    }

    QDECREF(bs->options);

    QDECREF(options);
@@ -1928,6 +1924,7 @@ void bdrv_close(BlockDriverState *bs) 
        BdrvChild *child, *next;



        bs->drv->bdrv_close(bs);

        bs->drv = NULL;



        if (bs->backing_hd) {

            BlockDriverState *backing_hd = bs->backing_hd;
@@ -1935,6 +1932,11 @@ void bdrv_close(BlockDriverState *bs) 
            bdrv_unref(backing_hd);

        }



        if (bs->file != NULL) {

            bdrv_unref_child(bs, bs->file);

            bs->file = NULL;

        }



        QLIST_FOREACH_SAFE(child, &bs->children, next, next) {

            /* TODO Remove bdrv_unref() from drivers' close function and use

             * bdrv_unref_child() here */
@@ -1946,7 +1948,6 @@ void bdrv_close(BlockDriverState *bs) 


        g_free(bs->opaque);

        bs->opaque = NULL;

        bs->drv = NULL;

        bs->copy_on_read = 0;

        bs->backing_file[0] = '\0';

        bs->backing_format[0] = '\0';
@@ -1959,11 +1960,6 @@ void bdrv_close(BlockDriverState *bs) 
        bs->options = NULL;

        QDECREF(bs->full_open_options);

        bs->full_open_options = NULL;



        if (bs->file != NULL) {

            bdrv_unref(bs->file);

            bs->file = NULL;

        }

    }



    if (bs->blk) {
@@ -2566,7 +2562,7 @@ int64_t bdrv_get_allocated_file_size(BlockDriverState *bs) 
        return drv->bdrv_get_allocated_file_size(bs);

    }

    if (bs->file) {

        return bdrv_get_allocated_file_size(bs->file);

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

    }

    return -ENOTSUP;

}
@@ -3048,7 +3044,7 @@ int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, 
                          const char *tag)

{

    while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {

        bs = bs->file;

        bs = bs->file ? bs->file->bs : NULL;

    }



    if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
@@ -3061,7 +3057,7 @@ int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, 
int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)

{

    while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {

        bs = bs->file;

        bs = bs->file ? bs->file->bs : NULL;

    }



    if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
@@ -3074,7 +3070,7 @@ int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag) 
int bdrv_debug_resume(BlockDriverState *bs, const char *tag)

{

    while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {

        bs = bs->file;

        bs = bs->file ? bs->file->bs : NULL;

    }



    if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
@@ -3087,7 +3083,7 @@ int bdrv_debug_resume(BlockDriverState *bs, const char *tag) 
bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)

{

    while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {

        bs = bs->file;

        bs = bs->file ? bs->file->bs : NULL;

    }



    if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
@@ -3209,7 +3205,7 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 
    if (bs->drv->bdrv_invalidate_cache) {

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

    } else if (bs->file) {

        bdrv_invalidate_cache(bs->file, &local_err);

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

    }

    if (local_err) {

        error_propagate(errp, local_err);
@@ -3939,7 +3935,7 @@ void bdrv_detach_aio_context(BlockDriverState *bs) 
        bs->drv->bdrv_detach_aio_context(bs);

    }

    if (bs->file) {

        bdrv_detach_aio_context(bs->file);

        bdrv_detach_aio_context(bs->file->bs);

    }

    if (bs->backing_hd) {

        bdrv_detach_aio_context(bs->backing_hd);
@@ -3963,7 +3959,7 @@ void bdrv_attach_aio_context(BlockDriverState *bs, 
        bdrv_attach_aio_context(bs->backing_hd, new_context);

    }

    if (bs->file) {

        bdrv_attach_aio_context(bs->file, new_context);

        bdrv_attach_aio_context(bs->file->bs, new_context);

    }

    if (bs->drv->bdrv_attach_aio_context) {

        bs->drv->bdrv_attach_aio_context(bs, new_context);
@@ -4175,7 +4171,7 @@ void bdrv_refresh_filename(BlockDriverState *bs) 
    /* This BDS's file name will most probably depend on its file's name, so

     * refresh that first */

    if (bs->file) {

        bdrv_refresh_filename(bs->file);

        bdrv_refresh_filename(bs->file->bs);

    }



    if (drv->bdrv_refresh_filename) {
@@ -4203,19 +4199,20 @@ void bdrv_refresh_filename(BlockDriverState *bs) 


        /* If no specific options have been given for this BDS, the filename of

         * the underlying file should suffice for this one as well */

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

            strcpy(bs->exact_filename, bs->file->exact_filename);

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

            strcpy(bs->exact_filename, bs->file->bs->exact_filename);

        }

        /* Reconstructing the full options QDict is simple for most format block

         * drivers, as long as the full options are known for the underlying

         * file BDS. The full options QDict of that file BDS should somehow

         * contain a representation of the filename, therefore the following

         * suffices without querying the (exact_)filename of this BDS. */

        if (bs->file->full_open_options) {

        if (bs->file->bs->full_open_options) {

            qdict_put_obj(opts, "driver",

                          QOBJECT(qstring_from_str(drv->format_name)));

            QINCREF(bs->file->full_open_options);

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

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

            qdict_put_obj(opts, "file",

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



            bs->full_open_options = opts;

        } else {

block/blkdebug.c

+17 −15
Original line number Diff line number Diff line
@@ -427,10 +427,10 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 
    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",

    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

+19 −14
Original line number Diff line number Diff line
@@ -123,10 +123,10 @@ 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;

    }
@@ -238,13 +238,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->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;

}
@@ -259,7 +259,7 @@ static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs, 


    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;

}
@@ -279,7 +279,7 @@ 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;
@@ -308,15 +308,17 @@ static void blkverify_refresh_filename(BlockDriverState *bs) 
{

    BDRVBlkverifyState *s = bs->opaque;



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

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

    bdrv_refresh_filename(s->test_file->bs);



    if (bs->file->full_open_options && s->test_file->bs->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(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));
@@ -324,10 +326,13 @@ static void blkverify_refresh_filename(BlockDriverState *bs) 
        bs->full_open_options = opts;

    }



    if (bs->file->exact_filename[0] && s->test_file->bs->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->bs->exact_filename);

                 bs->file->bs->exact_filename,

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

    }

}

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;

            }

block/cloop.c

+5 −5
Original line number Diff line number Diff line
@@ -66,7 +66,7 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, 
    bs->read_only = 1;



    /* read header */

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

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

    if (ret < 0) {

        return ret;

    }
@@ -92,7 +92,7 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, 
        return -EINVAL;

    }



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

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

    if (ret < 0) {

        return ret;

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

    }



    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size);

    ret = bdrv_pread(bs->file->bs, 128 + 4 + 4, s->offsets, offsets_size);

    if (ret < 0) {

        goto fail;

    }
@@ -203,8 +203,8 @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num) 
        int ret;

        uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];



        ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block,

                         bytes);

        ret = bdrv_pread(bs->file->bs, s->offsets[block_num],

                         s->compressed_block, bytes);

        if (ret != bytes) {

            return -1;

        }