Commit 7c8eece4 authored by Kevin Wolf's avatar Kevin Wolf
Browse files

block: Avoid bs->blk in bdrv_next() 



We need to introduce a separate BdrvNextIterator struct that can keep
more state than just the current BDS in order to avoid using the bs->blk
pointer.

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
parent dde33812

block.c

+12 −28
Original line number Diff line number Diff line
@@ -2870,25 +2870,6 @@ BlockDriverState *bdrv_next_node(BlockDriverState *bs) 
    return QTAILQ_NEXT(bs, node_list);

}



/* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by

 * the monitor or attached to a BlockBackend */

BlockDriverState *bdrv_next(BlockDriverState *bs)

{

    if (!bs || bs->blk) {

        bs = blk_next_root_bs(bs);

        if (bs) {

            return bs;

        }

    }



    /* Ignore all BDSs that are attached to a BlockBackend here; they have been

     * handled by the above block already */

    do {

        bs = bdrv_next_monitor_owned(bs);

    } while (bs && bs->blk);

    return bs;

}



const char *bdrv_get_node_name(const BlockDriverState *bs)

{

    return bs->node_name;
@@ -3220,10 +3201,11 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 


void bdrv_invalidate_cache_all(Error **errp)

{

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    Error *local_err = NULL;

    BdrvNextIterator *it = NULL;



    while ((bs = bdrv_next(bs)) != NULL) {

    while ((it = bdrv_next(it, &bs)) != NULL) {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        aio_context_acquire(aio_context);
@@ -3265,10 +3247,11 @@ static int bdrv_inactivate_recurse(BlockDriverState *bs, 
int bdrv_inactivate_all(void)

{

    BlockDriverState *bs = NULL;

    BdrvNextIterator *it = NULL;

    int ret = 0;

    int pass;



    while ((bs = bdrv_next(bs)) != NULL) {

    while ((it = bdrv_next(it, &bs)) != NULL) {

        aio_context_acquire(bdrv_get_aio_context(bs));

    }
@@ -3277,8 +3260,8 @@ int bdrv_inactivate_all(void) 
     * the second pass sets the BDRV_O_INACTIVE flag so that no further write

     * is allowed. */

    for (pass = 0; pass < 2; pass++) {

        bs = NULL;

        while ((bs = bdrv_next(bs)) != NULL) {

        it = NULL;

        while ((it = bdrv_next(it, &bs)) != NULL) {

            ret = bdrv_inactivate_recurse(bs, pass);

            if (ret < 0) {

                goto out;
@@ -3287,8 +3270,8 @@ int bdrv_inactivate_all(void) 
    }



out:

    bs = NULL;

    while ((bs = bdrv_next(bs)) != NULL) {

    it = NULL;

    while ((it = bdrv_next(it, &bs)) != NULL) {

        aio_context_release(bdrv_get_aio_context(bs));

    }
@@ -3781,10 +3764,11 @@ bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs, 
 */

bool bdrv_is_first_non_filter(BlockDriverState *candidate)

{

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;



    /* walk down the bs forest recursively */

    while ((bs = bdrv_next(bs)) != NULL) {

    while ((it = bdrv_next(it, &bs)) != NULL) {

        bool perm;



        /* try to recurse in this top level bs */

block/block-backend.c

+50 −22
Original line number Diff line number Diff line
@@ -75,6 +75,7 @@ static const AIOCBInfo block_backend_aiocb_info = { 
};



static void drive_info_del(DriveInfo *dinfo);

static BlockBackend *bdrv_first_blk(BlockDriverState *bs);



/* All BlockBackends */

static QTAILQ_HEAD(, BlockBackend) block_backends =
@@ -286,28 +287,50 @@ BlockBackend *blk_next(BlockBackend *blk) 
               : QTAILQ_FIRST(&monitor_block_backends);

}



/*

 * Iterates over all BlockDriverStates which are attached to a BlockBackend.

 * This function is for use by bdrv_next().

 *

 * @bs must be NULL or a BDS that is attached to a BB.

 */

BlockDriverState *blk_next_root_bs(BlockDriverState *bs)

{

struct BdrvNextIterator {

    enum {

        BDRV_NEXT_BACKEND_ROOTS,

        BDRV_NEXT_MONITOR_OWNED,

    } phase;

    BlockBackend *blk;

    BlockDriverState *bs;

};



    if (bs) {

        assert(bs->blk);

        blk = bs->blk;

    } else {

        blk = NULL;

/* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by

 * the monitor or attached to a BlockBackend */

BdrvNextIterator *bdrv_next(BdrvNextIterator *it, BlockDriverState **bs)

{

    if (!it) {

        it = g_new(BdrvNextIterator, 1);

        *it = (BdrvNextIterator) {

            .phase = BDRV_NEXT_BACKEND_ROOTS,

        };

    }



    /* 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) {

        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 (*bs) {

            return it;

        }

        it->phase = BDRV_NEXT_MONITOR_OWNED;

    }



    /* Then return the monitor-owned BDSes without a BB attached. Ignore all

     * BDSes that are attached to a BlockBackend here; they have been handled

     * by the above block already */

    do {

        blk = blk_all_next(blk);

    } while (blk && !blk->root);

        it->bs = bdrv_next_monitor_owned(it->bs);

        *bs = it->bs;

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



    return blk ? blk->root->bs : NULL;

    return *bs ? it : NULL;

}



/*
@@ -394,21 +417,26 @@ BlockDriverState *blk_bs(BlockBackend *blk) 
    return blk->root ? blk->root->bs : NULL;

}



/*

 * Returns true if @bs has an associated BlockBackend.

 */

bool bdrv_has_blk(BlockDriverState *bs)

static BlockBackend *bdrv_first_blk(BlockDriverState *bs)

{

    BdrvChild *child;

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

        if (child->role == &child_root) {

            assert(bs->blk);

            return true;

            return child->opaque;

        }

    }



    assert(!bs->blk);

    return false;

    return NULL;

}



/*

 * Returns true if @bs has an associated BlockBackend.

 */

bool bdrv_has_blk(BlockDriverState *bs)

{

    return bdrv_first_blk(bs) != NULL;

}



/*

block/io.c

+7 −6
Original line number Diff line number Diff line
@@ -270,10 +270,11 @@ void bdrv_drain_all(void) 
{

    /* Always run first iteration so any pending completion BHs run */

    bool busy = true;

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;

    GSList *aio_ctxs = NULL, *ctx;



    while ((bs = bdrv_next(bs))) {

    while ((it = bdrv_next(it, &bs))) {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        aio_context_acquire(aio_context);
@@ -301,10 +302,10 @@ void bdrv_drain_all(void) 


        for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {

            AioContext *aio_context = ctx->data;

            bs = NULL;

            it = NULL;



            aio_context_acquire(aio_context);

            while ((bs = bdrv_next(bs))) {

            while ((it = bdrv_next(it, &bs))) {

                if (aio_context == bdrv_get_aio_context(bs)) {

                    if (bdrv_requests_pending(bs)) {

                        busy = true;
@@ -317,8 +318,8 @@ void bdrv_drain_all(void) 
        }

    }



    bs = NULL;

    while ((bs = bdrv_next(bs))) {

    it = NULL;

    while ((it = bdrv_next(it, &bs))) {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        aio_context_acquire(aio_context);

block/snapshot.c

+18 −12
Original line number Diff line number Diff line
@@ -373,9 +373,10 @@ int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs, 
bool bdrv_all_can_snapshot(BlockDriverState **first_bad_bs)

{

    bool ok = true;

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;



    while (ok && (bs = bdrv_next(bs))) {

    while (ok && (it = bdrv_next(it, &bs))) {

        AioContext *ctx = bdrv_get_aio_context(bs);



        aio_context_acquire(ctx);
@@ -393,10 +394,11 @@ int bdrv_all_delete_snapshot(const char *name, BlockDriverState **first_bad_bs, 
                             Error **err)

{

    int ret = 0;

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;

    QEMUSnapshotInfo sn1, *snapshot = &sn1;



    while (ret == 0 && (bs = bdrv_next(bs))) {

    while (ret == 0 && (it = bdrv_next(it, &bs))) {

        AioContext *ctx = bdrv_get_aio_context(bs);



        aio_context_acquire(ctx);
@@ -415,9 +417,10 @@ int bdrv_all_delete_snapshot(const char *name, BlockDriverState **first_bad_bs, 
int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs)

{

    int err = 0;

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;



    while (err == 0 && (bs = bdrv_next(bs))) {

    while (err == 0 && (it = bdrv_next(it, &bs))) {

        AioContext *ctx = bdrv_get_aio_context(bs);



        aio_context_acquire(ctx);
@@ -435,9 +438,10 @@ int bdrv_all_find_snapshot(const char *name, BlockDriverState **first_bad_bs) 
{

    QEMUSnapshotInfo sn;

    int err = 0;

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;



    while (err == 0 && (bs = bdrv_next(bs))) {

    while (err == 0 && (it = bdrv_next(it, &bs))) {

        AioContext *ctx = bdrv_get_aio_context(bs);



        aio_context_acquire(ctx);
@@ -457,9 +461,10 @@ int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn, 
                             BlockDriverState **first_bad_bs)

{

    int err = 0;

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;



    while (err == 0 && (bs = bdrv_next(bs))) {

    while (err == 0 && (it = bdrv_next(it, &bs))) {

        AioContext *ctx = bdrv_get_aio_context(bs);



        aio_context_acquire(ctx);
@@ -480,9 +485,10 @@ int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn, 
BlockDriverState *bdrv_all_find_vmstate_bs(void)

{

    bool not_found = true;

    BlockDriverState *bs = NULL;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;



    while (not_found && (bs = bdrv_next(bs))) {

    while (not_found && (it = bdrv_next(it, &bs))) {

        AioContext *ctx = bdrv_get_aio_context(bs);



        aio_context_acquire(ctx);

blockdev.c

+2 −1
Original line number Diff line number Diff line
@@ -4135,8 +4135,9 @@ BlockJobInfoList *qmp_query_block_jobs(Error **errp) 
{

    BlockJobInfoList *head = NULL, **p_next = &head;

    BlockDriverState *bs;

    BdrvNextIterator *it = NULL;



    for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {

    while ((it = bdrv_next(it, &bs))) {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        aio_context_acquire(aio_context);