Commit 481cad48 authored by Manos Pitsidianakis's avatar Manos Pitsidianakis Committed by Stefan Hajnoczi
Browse files

block: add bdrv_co_drain_end callback 



BlockDriverState has a bdrv_co_drain() callback but no equivalent for
the end of the drain. The throttle driver (block/throttle.c) needs a way
to mark the end of the drain in order to toggle io_limits_disabled
correctly, thus bdrv_co_drain_end is needed.

Signed-off-by: default avatarManos Pitsidianakis <el13635@mail.ntua.gr>
Reviewed-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: default avatarFam Zheng <famz@redhat.com>
Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
parent f90ea7ba

block/io.c

+34 −14
Original line number Diff line number Diff line
@@ -156,6 +156,7 @@ typedef struct { 
    Coroutine *co;

    BlockDriverState *bs;

    bool done;

    bool begin;

} BdrvCoDrainData;



static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
@@ -163,18 +164,23 @@ static void coroutine_fn bdrv_drain_invoke_entry(void *opaque) 
    BdrvCoDrainData *data = opaque;

    BlockDriverState *bs = data->bs;



    if (data->begin) {

        bs->drv->bdrv_co_drain(bs);

    } else {

        bs->drv->bdrv_co_drain_end(bs);

    }



    /* Set data->done before reading bs->wakeup.  */

    atomic_mb_set(&data->done, true);

    bdrv_wakeup(bs);

}



static void bdrv_drain_invoke(BlockDriverState *bs)

static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)

{

    BdrvCoDrainData data = { .bs = bs, .done = false };

    BdrvCoDrainData data = { .bs = bs, .done = false, .begin = begin};



    if (!bs->drv || !bs->drv->bdrv_co_drain) {

    if (!bs->drv || (begin && !bs->drv->bdrv_co_drain) ||

            (!begin && !bs->drv->bdrv_co_drain_end)) {

        return;

    }
@@ -183,15 +189,16 @@ static void bdrv_drain_invoke(BlockDriverState *bs) 
    BDRV_POLL_WHILE(bs, !data.done);

}



static bool bdrv_drain_recurse(BlockDriverState *bs)

static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)

{

    BdrvChild *child, *tmp;

    bool waited;



    waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0);



    /* Ensure any pending metadata writes are submitted to bs->file.  */

    bdrv_drain_invoke(bs);

    bdrv_drain_invoke(bs, begin);



    /* Wait for drained requests to finish */

    waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0);



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

        BlockDriverState *bs = child->bs;
@@ -208,7 +215,7 @@ static bool bdrv_drain_recurse(BlockDriverState *bs) 
             */

            bdrv_ref(bs);

        }

        waited |= bdrv_drain_recurse(bs);

        waited |= bdrv_drain_recurse(bs, begin);

        if (in_main_loop) {

            bdrv_unref(bs);

        }
@@ -224,12 +231,18 @@ static void bdrv_co_drain_bh_cb(void *opaque) 
    BlockDriverState *bs = data->bs;



    bdrv_dec_in_flight(bs);

    if (data->begin) {

        bdrv_drained_begin(bs);

    } else {

        bdrv_drained_end(bs);

    }



    data->done = true;

    aio_co_wake(co);

}



static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs)

static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,

                                                bool begin)

{

    BdrvCoDrainData data;
@@ -242,6 +255,7 @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs) 
        .co = qemu_coroutine_self(),

        .bs = bs,

        .done = false,

        .begin = begin,

    };

    bdrv_inc_in_flight(bs);

    aio_bh_schedule_oneshot(bdrv_get_aio_context(bs),
@@ -256,7 +270,7 @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs) 
void bdrv_drained_begin(BlockDriverState *bs)

{

    if (qemu_in_coroutine()) {

        bdrv_co_yield_to_drain(bs);

        bdrv_co_yield_to_drain(bs, true);

        return;

    }
@@ -265,17 +279,22 @@ void bdrv_drained_begin(BlockDriverState *bs) 
        bdrv_parent_drained_begin(bs);

    }



    bdrv_drain_recurse(bs);

    bdrv_drain_recurse(bs, true);

}



void bdrv_drained_end(BlockDriverState *bs)

{

    if (qemu_in_coroutine()) {

        bdrv_co_yield_to_drain(bs, false);

        return;

    }

    assert(bs->quiesce_counter > 0);

    if (atomic_fetch_dec(&bs->quiesce_counter) > 1) {

        return;

    }



    bdrv_parent_drained_end(bs);

    bdrv_drain_recurse(bs, false);

    aio_enable_external(bdrv_get_aio_context(bs));

}
@@ -353,7 +372,7 @@ void bdrv_drain_all_begin(void) 
            aio_context_acquire(aio_context);

            for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {

                if (aio_context == bdrv_get_aio_context(bs)) {

                    waited |= bdrv_drain_recurse(bs);

                    waited |= bdrv_drain_recurse(bs, true);

                }

            }

            aio_context_release(aio_context);
@@ -374,6 +393,7 @@ void bdrv_drain_all_end(void) 
        aio_context_acquire(aio_context);

        aio_enable_external(aio_context);

        bdrv_parent_drained_end(bs);

        bdrv_drain_recurse(bs, false);

        aio_context_release(aio_context);

    }

include/block/block_int.h

+9 −2
Original line number Diff line number Diff line
@@ -354,10 +354,17 @@ struct BlockDriver { 
    int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo);



    /**

     * Drain and stop any internal sources of requests in the driver, and

     * remain so until next I/O callback (e.g. bdrv_co_writev) is called.

     * bdrv_co_drain is called if implemented in the beginning of a

     * drain operation to drain and stop any internal sources of requests in

     * the driver.

     * bdrv_co_drain_end is called if implemented at the end of the drain.

     *

     * They should be used by the driver to e.g. manage scheduled I/O

     * requests, or toggle an internal state. After the end of the drain new

     * requests will continue normally.

     */

    void coroutine_fn (*bdrv_co_drain)(BlockDriverState *bs);

    void coroutine_fn (*bdrv_co_drain_end)(BlockDriverState *bs);



    void (*bdrv_add_child)(BlockDriverState *parent, BlockDriverState *child,

                           Error **errp);