Commit c2066af0 authored by Kevin Wolf's avatar Kevin Wolf
Browse files

block: Drain throttling queue with BdrvChild callback 



This removes the last part of I/O throttling from block/io.c and moves
it to the BlockBackend.

Instead of having knowledge about throttling inside io.c, we can call a
BdrvChild callback .drained_begin/end, which happens to drain the
throttled requests for BlockBackend parents.

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarAlberto Garcia <berto@igalia.com>
Acked-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
parent 22aa8b24

block/block-backend.c

+27 −5
Original line number Diff line number Diff line
@@ -91,9 +91,14 @@ static void blk_root_inherit_options(int *child_flags, QDict *child_options, 
    /* We're not supposed to call this function for root nodes */

    abort();

}

static void blk_root_drained_begin(BdrvChild *child);

static void blk_root_drained_end(BdrvChild *child);



static const BdrvChildRole child_root = {

    .inherit_options    = blk_root_inherit_options,



    .drained_begin      = blk_root_drained_begin,

    .drained_end        = blk_root_drained_end,

};



/*
@@ -818,9 +823,9 @@ int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf, 
        return ret;

    }



    bdrv_no_throttling_begin(blk_bs(blk));

    blk_root_drained_begin(blk->root);

    ret = blk_pread(blk, offset, buf, count);

    bdrv_no_throttling_end(blk_bs(blk));

    blk_root_drained_end(blk->root);

    return ret;

}
@@ -1633,9 +1638,9 @@ void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg) 
void blk_io_limits_disable(BlockBackend *blk)

{

    assert(blk->public.throttle_state);

    bdrv_no_throttling_begin(blk_bs(blk));

    bdrv_drained_begin(blk_bs(blk));

    throttle_group_unregister_blk(blk);

    bdrv_no_throttling_end(blk_bs(blk));

    bdrv_drained_end(blk_bs(blk));

}



/* should be called before blk_set_io_limits if a limit is set */
@@ -1661,3 +1666,20 @@ void blk_io_limits_update_group(BlockBackend *blk, const char *group) 
    blk_io_limits_disable(blk);

    blk_io_limits_enable(blk, group);

}



static void blk_root_drained_begin(BdrvChild *child)

{

    BlockBackend *blk = child->opaque;



    if (blk->public.io_limits_disabled++ == 0) {

        throttle_group_restart_blk(blk);

    }

}



static void blk_root_drained_end(BdrvChild *child)

{

    BlockBackend *blk = child->opaque;



    assert(blk->public.io_limits_disabled);

    --blk->public.io_limits_disabled;

}

block/io.c

+18 −21
Original line number Diff line number Diff line
@@ -27,7 +27,6 @@ 
#include "sysemu/block-backend.h"

#include "block/blockjob.h"

#include "block/block_int.h"

#include "block/throttle-groups.h"

#include "qemu/cutils.h"

#include "qapi/error.h"

#include "qemu/error-report.h"
@@ -46,28 +45,26 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque); 
static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,

    int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);



void bdrv_no_throttling_begin(BlockDriverState *bs)

static void bdrv_parent_drained_begin(BlockDriverState *bs)

{

    if (!bs->blk) {

        return;

    }

    BdrvChild *c;



    if (blk_get_public(bs->blk)->io_limits_disabled++ == 0) {

        throttle_group_restart_blk(bs->blk);

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

        if (c->role->drained_begin) {

            c->role->drained_begin(c);

        }

    }

}



void bdrv_no_throttling_end(BlockDriverState *bs)

static void bdrv_parent_drained_end(BlockDriverState *bs)

{

    BlockBackendPublic *blkp;

    BdrvChild *c;



    if (!bs->blk) {

        return;

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

        if (c->role->drained_end) {

            c->role->drained_end(c);

        }

    }



    blkp = blk_get_public(bs->blk);

    assert(blkp->io_limits_disabled);

    --blkp->io_limits_disabled;

}



void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
@@ -248,17 +245,17 @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs) 
 */

void coroutine_fn bdrv_co_drain(BlockDriverState *bs)

{

    bdrv_no_throttling_begin(bs);

    bdrv_parent_drained_begin(bs);

    bdrv_io_unplugged_begin(bs);

    bdrv_drain_recurse(bs);

    bdrv_co_yield_to_drain(bs);

    bdrv_io_unplugged_end(bs);

    bdrv_no_throttling_end(bs);

    bdrv_parent_drained_end(bs);

}



void bdrv_drain(BlockDriverState *bs)

{

    bdrv_no_throttling_begin(bs);

    bdrv_parent_drained_begin(bs);

    bdrv_io_unplugged_begin(bs);

    bdrv_drain_recurse(bs);

    if (qemu_in_coroutine()) {
@@ -267,7 +264,7 @@ void bdrv_drain(BlockDriverState *bs) 
        bdrv_drain_poll(bs);

    }

    bdrv_io_unplugged_end(bs);

    bdrv_no_throttling_end(bs);

    bdrv_parent_drained_end(bs);

}



/*
@@ -290,7 +287,7 @@ void bdrv_drain_all(void) 
        if (bs->job) {

            block_job_pause(bs->job);

        }

        bdrv_no_throttling_begin(bs);

        bdrv_parent_drained_begin(bs);

        bdrv_io_unplugged_begin(bs);

        bdrv_drain_recurse(bs);

        aio_context_release(aio_context);
@@ -333,7 +330,7 @@ void bdrv_drain_all(void) 


        aio_context_acquire(aio_context);

        bdrv_io_unplugged_end(bs);

        bdrv_no_throttling_end(bs);

        bdrv_parent_drained_end(bs);

        if (bs->job) {

            block_job_resume(bs->job);

        }

include/block/block_int.h

+11 −5
Original line number Diff line number Diff line
@@ -364,6 +364,17 @@ typedef struct BdrvAioNotifier { 
struct BdrvChildRole {

    void (*inherit_options)(int *child_flags, QDict *child_options,

                            int parent_flags, QDict *parent_options);



    /*

     * If this pair of functions is implemented, the parent doesn't issue new

     * requests after returning from .drained_begin() until .drained_end() is

     * called.

     *

     * Note that this can be nested. If drained_begin() was called twice, new

     * I/O is allowed only after drained_end() was called twice, too.

     */

    void (*drained_begin)(BdrvChild *child);

    void (*drained_end)(BdrvChild *child);

};



extern const BdrvChildRole child_file;
@@ -526,8 +537,6 @@ int get_tmp_filename(char *filename, int size); 
BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,

                            const char *filename);



bool bdrv_start_throttled_reqs(BlockDriverState *bs);





/**

 * bdrv_add_before_write_notifier:
@@ -710,9 +719,6 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, 
                                  const BdrvChildRole *child_role);

void bdrv_root_unref_child(BdrvChild *child);



void bdrv_no_throttling_begin(BlockDriverState *bs);

void bdrv_no_throttling_end(BlockDriverState *bs);



void blk_dev_change_media_cb(BlockBackend *blk, bool load);

bool blk_dev_has_removable_media(BlockBackend *blk);

bool blk_dev_has_tray(BlockBackend *blk);