Commit 7a6d04e7 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging 



Block patches for 2.1.0-rc2 (v2)

# gpg: Signature made Mon 14 Jul 2014 11:04:12 BST using RSA key ID C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"

* remotes/kevin/tags/for-upstream: (22 commits)
  ide: Treat read/write beyond end as invalid
  virtio-blk: Treat read/write beyond end as invalid
  virtio-blk: Bypass error action and I/O accounting on invalid r/w
  virtio-blk: Factor common checks out of virtio_blk_handle_read/write()
  dma-helpers: Fix too long qiov
  qtest: fix vhost-user-test compilation with old GLib
  tests: Fix unterminated string output visitor enum human string
  AioContext: do not rely on aio_poll(ctx, true) result to end a loop
  virtio-blk: embed VirtQueueElement in VirtIOBlockReq
  virtio-blk: avoid g_slice_new0() for VirtIOBlockReq and VirtQueueElement
  dataplane: do not free VirtQueueElement in vring_push()
  virtio-blk: avoid dataplane VirtIOBlockReq early free
  block: Assert qiov length matches request length
  qed: Make qiov match request size until backing file EOF
  qcow2: Make qiov match request size until backing file EOF
  block: Make qiov match the request size until EOF
  AioContext: speed up aio_notify
  test-aio: fix GSource-based timer test
  block: drop aio functions that operate on the main AioContext
  block: prefer aio_poll to qemu_aio_wait
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents c15a34ed 58ac3211

aio-posix.c

+35 −3
Original line number Diff line number Diff line
@@ -125,7 +125,7 @@ static bool aio_dispatch(AioContext *ctx) 
    bool progress = false;



    /*

     * We have to walk very carefully in case qemu_aio_set_fd_handler is

     * We have to walk very carefully in case aio_set_fd_handler is

     * called while we're walking.

     */

    node = QLIST_FIRST(&ctx->aio_handlers);
@@ -175,27 +175,56 @@ static bool aio_dispatch(AioContext *ctx) 
bool aio_poll(AioContext *ctx, bool blocking)

{

    AioHandler *node;

    bool was_dispatching;

    int ret;

    bool progress;



    was_dispatching = ctx->dispatching;

    progress = false;



    /* aio_notify can avoid the expensive event_notifier_set if

     * everything (file descriptors, bottom halves, timers) will

     * be re-evaluated before the next blocking poll().  This happens

     * in two cases:

     *

     * 1) when aio_poll is called with blocking == false

     *

     * 2) when we are called after poll().  If we are called before

     *    poll(), bottom halves will not be re-evaluated and we need

     *    aio_notify() if blocking == true.

     *

     * The first aio_dispatch() only does something when AioContext is

     * running as a GSource, and in that case aio_poll is used only

     * with blocking == false, so this optimization is already quite

     * effective.  However, the code is ugly and should be restructured

     * to have a single aio_dispatch() call.  To do this, we need to

     * reorganize aio_poll into a prepare/poll/dispatch model like

     * glib's.

     *

     * If we're in a nested event loop, ctx->dispatching might be true.

     * In that case we can restore it just before returning, but we

     * have to clear it now.

     */

    aio_set_dispatching(ctx, !blocking);



    /*

     * If there are callbacks left that have been queued, we need to call them.

     * Do not call select in this case, because it is possible that the caller

     * does not need a complete flush (as is the case for qemu_aio_wait loops).

     * does not need a complete flush (as is the case for aio_poll loops).

     */

    if (aio_bh_poll(ctx)) {

        blocking = false;

        progress = true;

    }



    /* Re-evaluate condition (1) above.  */

    aio_set_dispatching(ctx, !blocking);

    if (aio_dispatch(ctx)) {

        progress = true;

    }



    if (progress && !blocking) {

        return true;

        goto out;

    }



    ctx->walking_handlers++;
@@ -234,9 +263,12 @@ bool aio_poll(AioContext *ctx, bool blocking) 
    }



    /* Run dispatch even if there were no readable fds to run timers */

    aio_set_dispatching(ctx, true);

    if (aio_dispatch(ctx)) {

        progress = true;

    }



out:

    aio_set_dispatching(ctx, was_dispatching);

    return progress;

}

aio-win32.c

+3 −3
Original line number Diff line number Diff line
@@ -102,7 +102,7 @@ bool aio_poll(AioContext *ctx, bool blocking) 
    /*

     * If there are callbacks left that have been queued, we need to call then.

     * Do not call select in this case, because it is possible that the caller

     * does not need a complete flush (as is the case for qemu_aio_wait loops).

     * does not need a complete flush (as is the case for aio_poll loops).

     */

    if (aio_bh_poll(ctx)) {

        blocking = false;
@@ -115,7 +115,7 @@ bool aio_poll(AioContext *ctx, bool blocking) 
    /*

     * Then dispatch any pending callbacks from the GSource.

     *

     * We have to walk very carefully in case qemu_aio_set_fd_handler is

     * We have to walk very carefully in case aio_set_fd_handler is

     * called while we're walking.

     */

    node = QLIST_FIRST(&ctx->aio_handlers);
@@ -177,7 +177,7 @@ bool aio_poll(AioContext *ctx, bool blocking) 
        blocking = false;



        /* we have to walk very carefully in case

         * qemu_aio_set_fd_handler is called while we're walking */

         * aio_set_fd_handler is called while we're walking */

        node = QLIST_FIRST(&ctx->aio_handlers);

        while (node) {

            AioHandler *tmp;

async.c

+18 −1
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include "block/aio.h"

#include "block/thread-pool.h"

#include "qemu/main-loop.h"

#include "qemu/atomic.h"



/***********************************************************/

/* bottom halves (can be seen as timers which expire ASAP) */
@@ -247,10 +248,26 @@ ThreadPool *aio_get_thread_pool(AioContext *ctx) 
    return ctx->thread_pool;

}



void aio_set_dispatching(AioContext *ctx, bool dispatching)

{

    ctx->dispatching = dispatching;

    if (!dispatching) {

        /* Write ctx->dispatching before reading e.g. bh->scheduled.

         * Optimization: this is only needed when we're entering the "unsafe"

         * phase where other threads must call event_notifier_set.

         */

        smp_mb();

    }

}



void aio_notify(AioContext *ctx)

{

    /* Write e.g. bh->scheduled before reading ctx->dispatching.  */

    smp_mb();

    if (!ctx->dispatching) {

        event_notifier_set(&ctx->notifier);

    }

}



static void aio_timerlist_notify(void *opaque)

{

block.c

+18 −4
Original line number Diff line number Diff line
@@ -471,7 +471,7 @@ int bdrv_create(BlockDriver *drv, const char* filename, 
        co = qemu_coroutine_create(bdrv_create_co_entry);

        qemu_coroutine_enter(co, &cco);

        while (cco.ret == NOT_DONE) {

            qemu_aio_wait();

            aio_poll(qemu_get_aio_context(), true);

        }

    }
@@ -3010,6 +3010,7 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, 


    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(!qiov || bytes == qiov->size);



    /* Handle Copy on Read and associated serialisation */

    if (flags & BDRV_REQ_COPY_ON_READ) {
@@ -3054,8 +3055,20 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, 
        max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),

                                  align >> BDRV_SECTOR_BITS);

        if (max_nb_sectors > 0) {

            ret = drv->bdrv_co_readv(bs, sector_num,

                                     MIN(nb_sectors, max_nb_sectors), qiov);

            QEMUIOVector local_qiov;

            size_t local_sectors;



            max_nb_sectors = MIN(max_nb_sectors, SIZE_MAX / BDRV_SECTOR_BITS);

            local_sectors = MIN(max_nb_sectors, nb_sectors);



            qemu_iovec_init(&local_qiov, qiov->niov);

            qemu_iovec_concat(&local_qiov, qiov, 0,

                              local_sectors * BDRV_SECTOR_SIZE);



            ret = drv->bdrv_co_readv(bs, sector_num, local_sectors,

                                     &local_qiov);



            qemu_iovec_destroy(&local_qiov);

        } else {

            ret = 0;

        }
@@ -3267,6 +3280,7 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, 


    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(!qiov || bytes == qiov->size);



    waited = wait_serialising_requests(req);

    assert(!waited || !req->serialising);
@@ -4040,7 +4054,7 @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, 
    if (ret < 0) {

        return ret;

    }

    return (ret & BDRV_BLOCK_ALLOCATED);

    return !!(ret & BDRV_BLOCK_ALLOCATED);

}



/*

block/backup.c

+1 −1
Original line number Diff line number Diff line
@@ -307,7 +307,7 @@ static void coroutine_fn backup_run(void *opaque) 
                                BACKUP_SECTORS_PER_CLUSTER - i, &n);

                    i += n;



                    if (alloced == 1) {

                    if (alloced == 1 || n == 0) {

                        break;

                    }

                }