Commit 88b062c2 authored by Paolo Bonzini's avatar Paolo Bonzini Committed by Fam Zheng
Browse files

block: introduce BDRV_POLL_WHILE 



We want the BDS event loop to run exclusively in the iothread that
owns the BDS's AioContext.  This macro will provide the synchronization
between the two event loops; for now it just wraps the common idiom
of a while loop around aio_poll.

Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
Reviewed-by: default avatarFam Zheng <famz@redhat.com>
Message-Id: <1477565348-5458-8-git-send-email-pbonzini@redhat.com>
Signed-off-by: default avatarFam Zheng <famz@redhat.com>
parent 6653a73d

block/block-backend.c

+1 −6
Original line number Diff line number Diff line
@@ -878,7 +878,6 @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf, 
                   int64_t bytes, CoroutineEntry co_entry,

                   BdrvRequestFlags flags)

{

    AioContext *aio_context;

    QEMUIOVector qiov;

    struct iovec iov;

    Coroutine *co;
@@ -900,11 +899,7 @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf, 


    co = qemu_coroutine_create(co_entry, &rwco);

    qemu_coroutine_enter(co);



    aio_context = blk_get_aio_context(blk);

    while (rwco.ret == NOT_DONE) {

        aio_poll(aio_context, true);

    }

    BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);



    return rwco.ret;

}

block/io.c

+5 −32
Original line number Diff line number Diff line
@@ -156,23 +156,12 @@ bool bdrv_requests_pending(BlockDriverState *bs) 
    return false;

}



static bool bdrv_drain_poll(BlockDriverState *bs)

{

    bool waited = false;



    while (atomic_read(&bs->in_flight) > 0) {

        aio_poll(bdrv_get_aio_context(bs), true);

        waited = true;

    }

    return waited;

}



static bool bdrv_drain_recurse(BlockDriverState *bs)

{

    BdrvChild *child;

    bool waited;



    waited = bdrv_drain_poll(bs);

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



    if (bs->drv && bs->drv->bdrv_drain) {

        bs->drv->bdrv_drain(bs);
@@ -597,13 +586,9 @@ static int bdrv_prwv_co(BdrvChild *child, int64_t offset, 
        /* Fast-path if already in coroutine context */

        bdrv_rw_co_entry(&rwco);

    } else {

        AioContext *aio_context = bdrv_get_aio_context(child->bs);



        co = qemu_coroutine_create(bdrv_rw_co_entry, &rwco);

        qemu_coroutine_enter(co);

        while (rwco.ret == NOT_DONE) {

            aio_poll(aio_context, true);

        }

        BDRV_POLL_WHILE(child->bs, rwco.ret == NOT_DONE);

    }

    return rwco.ret;

}
@@ -1845,14 +1830,10 @@ int64_t bdrv_get_block_status_above(BlockDriverState *bs, 
        /* Fast-path if already in coroutine context */

        bdrv_get_block_status_above_co_entry(&data);

    } else {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        co = qemu_coroutine_create(bdrv_get_block_status_above_co_entry,

                                   &data);

        qemu_coroutine_enter(co);

        while (!data.done) {

            aio_poll(aio_context, true);

        }

        BDRV_POLL_WHILE(bs, !data.done);

    }

    return data.ret;

}
@@ -2379,13 +2360,9 @@ int bdrv_flush(BlockDriverState *bs) 
        /* Fast-path if already in coroutine context */

        bdrv_flush_co_entry(&flush_co);

    } else {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        co = qemu_coroutine_create(bdrv_flush_co_entry, &flush_co);

        qemu_coroutine_enter(co);

        while (flush_co.ret == NOT_DONE) {

            aio_poll(aio_context, true);

        }

        BDRV_POLL_WHILE(bs, flush_co.ret == NOT_DONE);

    }



    return flush_co.ret;
@@ -2511,13 +2488,9 @@ int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int count) 
        /* Fast-path if already in coroutine context */

        bdrv_pdiscard_co_entry(&rwco);

    } else {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        co = qemu_coroutine_create(bdrv_pdiscard_co_entry, &rwco);

        qemu_coroutine_enter(co);

        while (rwco.ret == NOT_DONE) {

            aio_poll(aio_context, true);

        }

        BDRV_POLL_WHILE(bs, rwco.ret == NOT_DONE);

    }



    return rwco.ret;

block/qed-table.c

+4 −12
Original line number Diff line number Diff line
@@ -174,9 +174,7 @@ int qed_read_l1_table_sync(BDRVQEDState *s) 


    qed_read_table(s, s->header.l1_table_offset,

                   s->l1_table, qed_sync_cb, &ret);

    while (ret == -EINPROGRESS) {

        aio_poll(bdrv_get_aio_context(s->bs), true);

    }

    BDRV_POLL_WHILE(s->bs, ret == -EINPROGRESS);



    return ret;

}
@@ -195,9 +193,7 @@ int qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, 
    int ret = -EINPROGRESS;



    qed_write_l1_table(s, index, n, qed_sync_cb, &ret);

    while (ret == -EINPROGRESS) {

        aio_poll(bdrv_get_aio_context(s->bs), true);

    }

    BDRV_POLL_WHILE(s->bs, ret == -EINPROGRESS);



    return ret;

}
@@ -268,9 +264,7 @@ int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset 
    int ret = -EINPROGRESS;



    qed_read_l2_table(s, request, offset, qed_sync_cb, &ret);

    while (ret == -EINPROGRESS) {

        aio_poll(bdrv_get_aio_context(s->bs), true);

    }

    BDRV_POLL_WHILE(s->bs, ret == -EINPROGRESS);



    return ret;

}
@@ -290,9 +284,7 @@ int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request, 
    int ret = -EINPROGRESS;



    qed_write_l2_table(s, request, index, n, flush, qed_sync_cb, &ret);

    while (ret == -EINPROGRESS) {

        aio_poll(bdrv_get_aio_context(s->bs), true);

    }

    BDRV_POLL_WHILE(s->bs, ret == -EINPROGRESS);



    return ret;

}

include/block/block.h

+9 −0
Original line number Diff line number Diff line
@@ -334,6 +334,15 @@ void bdrv_drain(BlockDriverState *bs); 
void coroutine_fn bdrv_co_drain(BlockDriverState *bs);

void bdrv_drain_all(void);



#define BDRV_POLL_WHILE(bs, cond) ({                       \

    bool waited_ = false;                                  \

    BlockDriverState *bs_ = (bs);                          \

    while ((cond)) {                                       \

        aio_poll(bdrv_get_aio_context(bs_), true);         \

        waited_ = true;                                    \

    }                                                      \

    waited_; })



int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int count);

int bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset, int count);

int bdrv_has_zero_init_1(BlockDriverState *bs);