Commit 9540d1f8 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging 



Block pull request

# gpg: Signature made Mon 07 Jul 2014 13:27:20 BST using RSA key ID 81AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>"
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>"

* remotes/stefanha/tags/block-pull-request:
  qmp: show QOM properties in device-list-properties
  dataplane: submit I/O as a batch
  linux-aio: implement io plug, unplug and flush io queue
  block: block: introduce APIs for submitting IO as a batch
  ahci: map memory via device's address space instead of address_space_memory
  raw-posix: Fix raw_getlength() to always return -errno on error
  qemu-iotests: Disable Quorum testing in 041 when Quorum is not builtin
  ahci.c: mask unused flags when reading size PRDT DBC
  MAINTAINERS: add Stefan Hajnoczi to IDE maintainers
  mirror: Fix qiov size for short requests
  Fix nocow typos in manpage

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents f811d474 f4eb32b5

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -563,6 +563,7 @@ Devices 
-------

IDE

M: Kevin Wolf <kwolf@redhat.com>

M: Stefan Hajnoczi <stefanha@redhat.com>

S: Odd Fixes

F: include/hw/ide.h

F: hw/ide/

block.c

+31 −0
Original line number Diff line number Diff line
@@ -1905,6 +1905,7 @@ void bdrv_drain_all(void) 
            bool bs_busy;



            aio_context_acquire(aio_context);

            bdrv_flush_io_queue(bs);

            bdrv_start_throttled_reqs(bs);

            bs_busy = bdrv_requests_pending(bs);

            bs_busy |= aio_poll(aio_context, bs_busy);
@@ -5782,3 +5783,33 @@ BlockDriverState *check_to_replace_node(const char *node_name, Error **errp) 


    return to_replace_bs;

}



void bdrv_io_plug(BlockDriverState *bs)

{

    BlockDriver *drv = bs->drv;

    if (drv && drv->bdrv_io_plug) {

        drv->bdrv_io_plug(bs);

    } else if (bs->file) {

        bdrv_io_plug(bs->file);

    }

}



void bdrv_io_unplug(BlockDriverState *bs)

{

    BlockDriver *drv = bs->drv;

    if (drv && drv->bdrv_io_unplug) {

        drv->bdrv_io_unplug(bs);

    } else if (bs->file) {

        bdrv_io_unplug(bs->file);

    }

}



void bdrv_flush_io_queue(BlockDriverState *bs)

{

    BlockDriver *drv = bs->drv;

    if (drv && drv->bdrv_flush_io_queue) {

        drv->bdrv_flush_io_queue(bs);

    } else if (bs->file) {

        bdrv_flush_io_queue(bs->file);

    }

}

block/linux-aio.c

+94 −2
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ 
 */

#define MAX_EVENTS 128



#define MAX_QUEUED_IO  128



struct qemu_laiocb {

    BlockDriverAIOCB common;

    struct qemu_laio_state *ctx;
@@ -36,9 +38,19 @@ struct qemu_laiocb { 
    QLIST_ENTRY(qemu_laiocb) node;

};



typedef struct {

    struct iocb *iocbs[MAX_QUEUED_IO];

    int plugged;

    unsigned int size;

    unsigned int idx;

} LaioQueue;



struct qemu_laio_state {

    io_context_t ctx;

    EventNotifier e;



    /* io queue for submit at batch */

    LaioQueue io_q;

};



static inline ssize_t io_event_ret(struct io_event *ev)
@@ -135,6 +147,79 @@ static const AIOCBInfo laio_aiocb_info = { 
    .cancel             = laio_cancel,

};



static void ioq_init(LaioQueue *io_q)

{

    io_q->size = MAX_QUEUED_IO;

    io_q->idx = 0;

    io_q->plugged = 0;

}



static int ioq_submit(struct qemu_laio_state *s)

{

    int ret, i = 0;

    int len = s->io_q.idx;



    do {

        ret = io_submit(s->ctx, len, s->io_q.iocbs);

    } while (i++ < 3 && ret == -EAGAIN);



    /* empty io queue */

    s->io_q.idx = 0;



    if (ret < 0) {

        i = 0;

    } else {

        i = ret;

    }



    for (; i < len; i++) {

        struct qemu_laiocb *laiocb =

            container_of(s->io_q.iocbs[i], struct qemu_laiocb, iocb);



        laiocb->ret = (ret < 0) ? ret : -EIO;

        qemu_laio_process_completion(s, laiocb);

    }

    return ret;

}



static void ioq_enqueue(struct qemu_laio_state *s, struct iocb *iocb)

{

    unsigned int idx = s->io_q.idx;



    s->io_q.iocbs[idx++] = iocb;

    s->io_q.idx = idx;



    /* submit immediately if queue is full */

    if (idx == s->io_q.size) {

        ioq_submit(s);

    }

}



void laio_io_plug(BlockDriverState *bs, void *aio_ctx)

{

    struct qemu_laio_state *s = aio_ctx;



    s->io_q.plugged++;

}



int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug)

{

    struct qemu_laio_state *s = aio_ctx;

    int ret = 0;



    assert(s->io_q.plugged > 0 || !unplug);



    if (unplug && --s->io_q.plugged > 0) {

        return 0;

    }



    if (s->io_q.idx > 0) {

        ret = ioq_submit(s);

    }



    return ret;

}



BlockDriverAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd,

        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,

        BlockDriverCompletionFunc *cb, void *opaque, int type)
@@ -168,8 +253,13 @@ BlockDriverAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, 
    }

    io_set_eventfd(&laiocb->iocb, event_notifier_get_fd(&s->e));



    if (io_submit(s->ctx, 1, &iocbs) < 0)

    if (!s->io_q.plugged) {

        if (io_submit(s->ctx, 1, &iocbs) < 0) {

            goto out_free_aiocb;

        }

    } else {

        ioq_enqueue(s, iocbs);

    }

    return &laiocb->common;



out_free_aiocb:
@@ -204,6 +294,8 @@ void *laio_init(void) 
        goto out_close_efd;

    }



    ioq_init(&s->io_q);



    return s;



out_close_efd:

block/mirror.c

+3 −1
Original line number Diff line number Diff line
@@ -265,9 +265,11 @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s) 
    next_sector = sector_num;

    while (nb_chunks-- > 0) {

        MirrorBuffer *buf = QSIMPLEQ_FIRST(&s->buf_free);

        size_t remaining = (nb_sectors * BDRV_SECTOR_SIZE) - op->qiov.size;



        QSIMPLEQ_REMOVE_HEAD(&s->buf_free, next);

        s->buf_free_count--;

        qemu_iovec_add(&op->qiov, buf, s->granularity);

        qemu_iovec_add(&op->qiov, buf, MIN(s->granularity, remaining));



        /* Advance the HBitmapIter in parallel, so that we do not examine

         * the same sector twice.

block/raw-aio.h

+2 −0
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ BlockDriverAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, 
        BlockDriverCompletionFunc *cb, void *opaque, int type);

void laio_detach_aio_context(void *s, AioContext *old_context);

void laio_attach_aio_context(void *s, AioContext *new_context);

void laio_io_plug(BlockDriverState *bs, void *aio_ctx);

int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug);

#endif



#ifdef _WIN32