Skip to contentSkip to conversation

block-queue: Delay and batch metadata writes

RFC PATCH In review Kevin Wolf 2 participants 9 messages Dec 1, 2010 – Dec 3, 2010

Subsystems (2)
lore
Share & tools
lore

Kevin Wolf

author
#0 lore raw

v3 cover block-queue: Delay and batch metadata writes

block-queue itself looks more or less ready to me now, the rest is possible bug fixes and addressing review comments. So please, give the first three patches a good review, they are in their final version otherwise.

This series is only marked RFC because proper qcow2 integration is missing and merging block-queue doesn't make much sense without a user.

Patch 4/4 contains a hackish version of qcow2 integration which I think should fully work (I think I addressed Stefan's comment), but is too ugly to be merged.

Kevin Wolf (4):
block: Implement bdrv_aio_pwrite
Add block-queue
Test cases for block-queue
qcow2: Preliminary block-queue support

 Makefile               |    1 +
 Makefile.objs          |    2 +-
 block-queue.c          |  736 ++++++++++++++++++++++++++++++++++++++++++++++++
 block-queue.h          |   61 ++++
 block.c                |  167 +++++++++++
 block.h                |    2 +
 block/qcow2-cluster.c  |   39 ++--
 block/qcow2-refcount.c |   62 ++--
 block/qcow2.c          |   83 ++++++-
 block/qcow2.h          |    5 +
 check-block-queue.c    |  402 ++++++++++++++++++++++++++
 cpus.c                 |    8 +-
 qemu-common.h          |    3 +
 qemu-tool.c            |    5 +
 sysemu.h               |    1 -
 15 files changed, 1521 insertions(+), 56 deletions(-)
 create mode 100644 block-queue.c
 create mode 100644 block-queue.h
 create mode 100644 check-block-queue.c
Signature · 1 line
1.7.2.3
author
#1 lore raw

RFC PATCH v3 1/4 block: Implement bdrv_aio_pwrite

This implements an asynchronous version of bdrv_pwrite.

---
 block.c |  167 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 block.h |    2 +
 2 files changed, 169 insertions(+), 0 deletions(-)
block.c +167 -0
index 63effd8..f10066e 100644
@@ -2106,6 +2106,173 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
     return ret;
 }
 
+typedef struct PwriteAIOCB {
+    BlockDriverAIOCB    common;
+    int                 state;
+    int64_t             offset;
+    size_t              bytes;
+    uint8_t*            buf;
+    uint8_t*            tmp_buf;
+    struct iovec        iov;
+    QEMUIOVector        qiov;
+} PwriteAIOCB;
+
+static void pwrite_aio_cancel(BlockDriverAIOCB *blockacb)
+{
+    qemu_aio_flush();
+}
+
+static AIOPool blkqueue_aio_pool = {
+    .aiocb_size         = sizeof(PwriteAIOCB),
+    .cancel             = pwrite_aio_cancel,
+};
+
+static void bdrv_aio_pwrite_cb(void *opaque, int ret)
+{
+    PwriteAIOCB *acb = opaque;
+    BlockDriverAIOCB *tmp_acb;
+    int64_t sector_num;
+
+    if (ret < 0) {
+        goto done;
+    }
+
+    sector_num = acb->offset >> BDRV_SECTOR_BITS;
+
+    switch (acb->state) {
+    case 0: {
+        /* Read first sector if needed */
+        int len;
+
+        len = (BDRV_SECTOR_SIZE - acb->offset) & (BDRV_SECTOR_SIZE - 1);
+
+        if (len > 0) {
+            acb->state = 1;
+            acb->tmp_buf = qemu_blockalign(acb->common.bs, BDRV_SECTOR_SIZE);
+            acb->iov.iov_base = acb->tmp_buf;
+            acb->iov.iov_len = BDRV_SECTOR_SIZE;
+            qemu_iovec_init_external(&acb->qiov, &acb->iov, 1);
+            tmp_acb = bdrv_aio_readv(acb->common.bs, sector_num, &acb->qiov, 1,
+                bdrv_aio_pwrite_cb, acb);
+            if (tmp_acb == NULL) {
+                bdrv_aio_pwrite_cb(acb, -EIO);
+            }
+        } else {
+            acb->state = 2;
+            bdrv_aio_pwrite_cb(acb, 0);
+        }
+        break;
+    }
+
+    case 1: {
+        /* Modify first cluster and write it back */
+        int len;
+
+        len = (BDRV_SECTOR_SIZE - acb->offset) & (BDRV_SECTOR_SIZE - 1);
+        if (len > acb->bytes) {
+            len = acb->bytes;
+        }
+
+        memcpy(acb->tmp_buf + (acb->offset & (BDRV_SECTOR_SIZE - 1)),
+            acb->buf, len);
+
+        acb->state = 2;
+        acb->offset += len;
+        acb->buf += len;
+        acb->bytes -= len;
+
+        tmp_acb = bdrv_aio_writev(acb->common.bs, sector_num, &acb->qiov, 1,
+            bdrv_aio_pwrite_cb, acb);
+        if (tmp_acb == NULL) {
+            bdrv_aio_pwrite_cb(acb, -EIO);
+        }
+        break;
+    }
+
+    case 2: {
+        /* Write the sectors "in place" */
+        int nb_sectors = acb->bytes >> BDRV_SECTOR_BITS;
+
+        acb->state = 3;
+        if (nb_sectors > 0) {
+            int len = nb_sectors << BDRV_SECTOR_BITS;
+
+            acb->iov.iov_base = acb->buf;
+            acb->iov.iov_len = len;
+            qemu_iovec_init_external(&acb->qiov, &acb->iov, 1);
+
+            acb->offset += len;
+            acb->buf += len;
+            acb->bytes -= len;
+
+            tmp_acb = bdrv_aio_writev(acb->common.bs, sector_num, &acb->qiov,
+                nb_sectors, bdrv_aio_pwrite_cb, acb);
+            if (tmp_acb == NULL) {
+                bdrv_aio_pwrite_cb(acb, -EIO);
+            }
+        } else {
+            bdrv_aio_pwrite_cb(acb, 0);
+        }
+        break;
+    }
+
+    case 3: {
+        /* Read last sector if needed */
+        if (acb->bytes == 0) {
+            goto done;
+        }
+
+        acb->state = 4;
+        acb->iov.iov_base = acb->tmp_buf;
+        acb->iov.iov_len = BDRV_SECTOR_SIZE;
+        qemu_iovec_init_external(&acb->qiov, &acb->iov, 1);
+        tmp_acb = bdrv_aio_readv(acb->common.bs, sector_num, &acb->qiov, 1,
+            bdrv_aio_pwrite_cb, acb);
+        if (tmp_acb == NULL) {
+            bdrv_aio_pwrite_cb(acb, -EIO);
+        }
+        break;
+    }
+
+    case 4:
+        /* Modify and write last sector */
+        acb->state = 5;
+        memcpy(acb->tmp_buf, acb->buf, acb->bytes);
+        tmp_acb = bdrv_aio_writev(acb->common.bs, sector_num, &acb->qiov, 1,
+            bdrv_aio_pwrite_cb, acb);
+        if (tmp_acb == NULL) {
+            bdrv_aio_pwrite_cb(acb, -EIO);
+        }
+        break;
+
+    case 5:
+        goto done;
+    }
+    return;
+
+done:
+    qemu_free(acb->tmp_buf);
+    acb->common.cb(acb->common.opaque, ret);
+    qemu_aio_release(acb);
+}
+
+BlockDriverAIOCB *bdrv_aio_pwrite(BlockDriverState *bs, int64_t offset,
+    void* buf, size_t bytes, BlockDriverCompletionFunc *cb, void *opaque)
+{
+    PwriteAIOCB *acb;
+
+    acb = qemu_aio_get(&blkqueue_aio_pool, bs, cb, opaque);
+    acb->state      = 0;
+    acb->offset     = offset;
+    acb->buf        = buf;
+    acb->bytes      = bytes;
+    acb->tmp_buf    = NULL;
+
+    bdrv_aio_pwrite_cb(acb, 0);
+
+    return &acb->common;
+}
+
 
 typedef struct MultiwriteCB {
     int error;
block.h +2 -0
index 78ecfac..c6e4d90 100644
@@ -116,6 +116,8 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                   QEMUIOVector *iov, int nb_sectors,
                                   BlockDriverCompletionFunc *cb, void *opaque);
+BlockDriverAIOCB *bdrv_aio_pwrite(BlockDriverState *bs, int64_t offset, void* buf,
+    size_t bytes, BlockDriverCompletionFunc *cb, void *opaque);
 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
 				 BlockDriverCompletionFunc *cb, void *opaque);
 void bdrv_aio_cancel(BlockDriverAIOCB *acb);
Signature · 1 line
1.7.2.3
#2 lore raw

[Qemu-devel] Re: [RFC PATCH v3 1/4] block: Implement bdrv_aio_pwrite

Quoted 7 lines · Kevin Wolf

This implements an asynchronous version of bdrv_pwrite.

---
 block.c |  167 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ block.h |    2 +

 2 files changed, 169 insertions(+), 0 deletions(-)

Is this function is necessary?

Current synchronous code uses pwrite() so this function makes it easy to convert existing code. But if that code took the block-based nature of storage into account then this read-modify-write helper isn't needed.

I guess what I'm saying is that this function should only be used when you really need rmw (in many cases with image metadata it can be avoided because you have enough metadata cached in memory to do full sector writes). If it turns out we don't need rmw then we can eliminate this function.

Quoted 3 lines

+    switch (acb->state) {
+    case 0: {
+        /* Read first sector if needed */

Please use an enum instead of int literals with comments. Or you could try separate functions and see if the switch statement really saves that many lines of code.

Quoted 8 lines

+    case 3: {
+        /* Read last sector if needed */
+        if (acb->bytes == 0) {
+            goto done;
+        }
+
+        acb->state = 4;
+        acb->iov.iov_base = acb->tmp_buf;

acb->tmp_buf may be NULL here if we took the state transition to 2 instead of doing 1.

Quoted 3 lines

+done:
+    qemu_free(acb->tmp_buf);
+    acb->common.cb(acb->common.opaque, ret);

Callback not invoked from a BH. In an error case we might have made no blocking calls, i.e. never returned and this callback can cause reentrancy.

block.c BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, · line 2271

Quoted 13 lines
block.c +13 -0
+BlockDriverAIOCB *bdrv_aio_pwrite(BlockDriverState *bs, int64_t offset,
+    void* buf, size_t bytes, BlockDriverCompletionFunc *cb, void *opaque)
+{
+    PwriteAIOCB *acb;
+
+    acb = qemu_aio_get(&blkqueue_aio_pool, bs, cb, opaque);
+    acb->state      = 0;
+    acb->offset     = offset;
+    acb->buf        = buf;
+    acb->bytes      = bytes;
+    acb->tmp_buf    = NULL;
+
+    bdrv_aio_pwrite_cb(acb, 0);

We're missing the usual !bs->drv, bs->read_only, bdrv_check_request() checks here. Are we okay to wait until calling bdrv_aio_readv/bdrv_aio_writev for these checks?

Stefan

author
#3 lore raw

[Qemu-devel] Re: [RFC PATCH v3 1/4] block: Implement bdrv_aio_pwrite

Am 02.12.2010 13:07, schrieb Stefan Hajnoczi:

Quoted 9 lines · Kevin Wolf
Quoted 7 lines

This implements an asynchronous version of bdrv_pwrite.

---
 block.c |  167 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 block.h |    2 +
 2 files changed, 169 insertions(+), 0 deletions(-)
Quoted 6 lines

Is this function is necessary?

Current synchronous code uses pwrite() so this function makes it easy to convert existing code. But if that code took the block-based nature of storage into account then this read-modify-write helper isn't needed.

For qcow2, most writes (refcount tables, L2 tables, etc.) are aligned to 512 byte sectors, but there are still some left that use pwrite with an unaligned count. I'm not completely sure which data, but qemu-iotests crashed with tmp_buf == NULL, so there are some ;-) Probably things like header and snapshot table writes.

I'm not sure what other image formats do (we might want to use block-queue for them, too, eventually), but usually that means that they do strange things.

Quoted 5 lines

I guess what I'm saying is that this function should only be used when you really need rmw (in many cases with image metadata it can be avoided because you have enough metadata cached in memory to do full sector writes). If it turns out we don't need rmw then we can eliminate this function.

Maybe what we really should do is completely change the block layer functions to use bytes as their unit and do any RMW in posix-aio-compat and linux-aio. Other backends don't need it and without O_DIRECT we don't even need to do it with files.

Also, using units of 512 bytes is completely arbitrary and may still involve RMW if the host uses a different sector size.

Quoted 7 lines

block.c BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, · line 2144

Quoted 3 lines
block.c +3 -0
+    switch (acb->state) {
+    case 0: {
+        /* Read first sector if needed */

Please use an enum instead of int literals with comments. Or you could try separate functions and see if the switch statement really saves that many lines of code.

Okay, will use an enum.

I think the switch may not save that many lines of code, but it improves readability because with chained functions (and no forward declarations) you have to read backwards.

Quoted 11 lines

block.c BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, · line 2226

Quoted 8 lines
block.c +8 -0
+    case 3: {
+        /* Read last sector if needed */
+        if (acb->bytes == 0) {
+            goto done;
+        }
+
+        acb->state = 4;
+        acb->iov.iov_base = acb->tmp_buf;

acb->tmp_buf may be NULL here if we took the state transition to 2 instead of doing 1.

Yup, is already fixed.

Quoted 7 lines

block.c BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, · line 2255

Quoted 3 lines
block.c +3 -0
+done:
+    qemu_free(acb->tmp_buf);
+    acb->common.cb(acb->common.opaque, ret);

Callback not invoked from a BH. In an error case we might have made no blocking calls, i.e. never returned and this callback can cause reentrancy.

Good point.

Quoted 9 lines
Quoted 9 lines
block.c +9 -0
+BlockDriverAIOCB *bdrv_aio_pwrite(BlockDriverState *bs, int64_t offset,
+    void* buf, size_t bytes, BlockDriverCompletionFunc *cb, void *opaque)
+{
+    PwriteAIOCB *acb;
+
+    acb = qemu_aio_get(&blkqueue_aio_pool, bs, cb, opaque);
+    acb->state      = 0;
+    acb->offset     = offset;
+    acb->buf        = buf;
Quoted 8 lines

block.c BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, · line 2271

Quoted 4 lines
block.c +4 -0
+    acb->bytes      = bytes;
+    acb->tmp_buf    = NULL;
+
+    bdrv_aio_pwrite_cb(acb, 0);

We're missing the usual !bs->drv, bs->read_only, bdrv_check_request() checks here. Are we okay to wait until calling bdrv_aio_readv/bdrv_aio_writev for these checks?

I think we are, but if you prefer, I can copy them here.

Kevin

#4 lore raw

[Qemu-devel] Re: [RFC PATCH v3 1/4] block: Implement bdrv_aio_pwrite

Quoted 8 lines · Kevin Wolf

Am 02.12.2010 13:07, schrieb Stefan Hajnoczi:

Quoted 6 lines · Kevin Wolf

I guess what I'm saying is that this function should only be used when you really need rmw (in many cases with image metadata it can be avoided because you have enough metadata cached in memory to do full sector writes).  If it turns out we don't need rmw then we can eliminate this function.

Quoted 4 lines

Maybe what we really should do is completely change the block layer functions to use bytes as their unit and do any RMW in posix-aio-compat and linux-aio. Other backends don't need it and without O_DIRECT we don't even need to do it with files.

Yeah that sounds like something worth exploring more. Perhaps together with some input from Christoph on moving QEMU to the native block size (e.g. 4k on some devices).

Quoted 18 lines
Quoted 9 lines
Quoted 9 lines
block.c +9 -0
+BlockDriverAIOCB *bdrv_aio_pwrite(BlockDriverState *bs, int64_t offset,
+    void* buf, size_t bytes, BlockDriverCompletionFunc *cb, void *opaque)
+{
+    PwriteAIOCB *acb;
+
+    acb = qemu_aio_get(&blkqueue_aio_pool, bs, cb, opaque);
+    acb->state      = 0;
+    acb->offset     = offset;
+    acb->buf        = buf;
Quoted 8 lines
Quoted 4 lines

+    acb->bytes      = bytes;
+    acb->tmp_buf    = NULL;
+
+    bdrv_aio_pwrite_cb(acb, 0);

We're missing the usual !bs->drv, bs->read_only, bdrv_check_request() checks here.  Are we okay to wait until calling bdrv_aio_readv/bdrv_aio_writev for these checks?

Quoted 1 line

I think we are, but if you prefer, I can copy them here.

No, I just wanted to make sure you took them into account. In theory those error cases won't affect your code and it's fine to wait for bdrv_aio_readv/bdrv_aio_writev to catch them. I haven't thought through the cases in detail though.

Stefan

author
#5 lore raw

RFC PATCH v3 2/4 Add block-queue

In reply to Kevin Wolf

Instead of directly executing writes and fsyncs, queue them and execute them asynchronously. What makes this interesting is that we can delay syncs and if multiple syncs occur, we can merge them into one bdrv_flush.

A typical sequence in qcow2 (simple cluster allocation) looks like this:

1. Update refcount table
2. bdrv_flush
3. Update L2 entry

If we delay the operation and get three of these sequences queued before actually executing, we end up with the following result, saving two syncs:

1. Update refcount table (req 1)
2. Update refcount table (req 2)
3. Update refcount table (req 3)
4. bdrv_flush
5. Update L2 entry (req 1)
6. Update L2 entry (req 2)
7. Update L2 entry (req 3)

This patch only commits a sync if either the guests has requested a flush or if a certain number of requests is in the queue, so usually we batch more than just three requests.

---
 Makefile.objs |    2 +-
 block-queue.c |  736 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 block-queue.h |   61 +++++
 3 files changed, 798 insertions(+), 1 deletions(-)
 create mode 100644 block-queue.c
 create mode 100644 block-queue.h
Makefile.objs +1 -1
index 23b17ce..76495f3 100644
@@ -14,7 +14,7 @@ oslib-obj-$(CONFIG_POSIX) += oslib-posix.o
 # block-obj-y is code used by both qemu system emulation and qemu-img
 
 block-obj-y = cutils.o cache-utils.o qemu-malloc.o qemu-option.o module.o
-block-obj-y += nbd.o block.o aio.o aes.o qemu-config.o
+block-obj-y += nbd.o block.o aio.o aes.o qemu-config.o block-queue.o
 block-obj-$(CONFIG_POSIX) += posix-aio-compat.o
 block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o
 
block-queue.c new file +736 -0

736 lines not on this page · raw message

block-queue.h new file +61 -0

61 lines not on this page · raw message

Signature · 1 line
1.7.2.3
#6 lore raw

[Qemu-devel] Re: [RFC PATCH v3 2/4] Add block-queue

Quoted 23 lines · Kevin Wolf
block-queue.c new file +23 -0
+/*
+ * Adds a write request to the queue.
+ */
+int blkqueue_pwrite(BlockQueueContext *context, uint64_t offset, void *buf,
+    uint64_t size)
+{
+    BlockQueue *bq = context->bq;
+    BlockQueueRequest *section_req;
+    bool completed;
+
+    /* Don't use the queue for writethrough images */
+    if ((bq->bs->open_flags & WRITEBACK_MODES) == 0) {
+        return bdrv_pwrite(bq->bs, offset, buf, size);
+    }
+
+    /* First check if there are any pending writes for the same data. */
+    DPRINTF("--        pwrite: [%#lx + %ld]\n", offset, size);
+    completed = blkqueue_check_queue_overlap(context, &bq->queue, &offset,
+        &buf, &size, &blkqueue_pwrite, &pwrite_handle_overlap,
+        context->section);
+
+    if (completed) {
+        return 0;

block-queue.c line 313

Quoted 10 lines
block-queue.c new file +10 -0
+    }
+
+    /* Create request structure */
+    BlockQueueRequest *req = qemu_malloc(sizeof(*req));
+    QLIST_INIT(&req->acbs);
+    req->type       = REQ_TYPE_WRITE;
+    req->bq         = bq;
+    req->offset     = offset;
+    req->size       = size;
+    req->buf        = qemu_malloc(size);

qemu_blockalign()

Quoted 26 lines
block-queue.c new file +26 -0
+static int insert_barrier(BlockQueueContext *context, BlockQueueAIOCB *acb)
+{
+    BlockQueue *bq = context->bq;
+    BlockQueueRequest *section_req;
+
+    bq->barriers_requested++;
+
+    /* Create request structure */
+    BlockQueueRequest *req = qemu_malloc(sizeof(*req));
+    QLIST_INIT(&req->acbs);
+    req->type       = REQ_TYPE_BARRIER;
+    req->bq         = bq;
+    req->section    = context->section;
+    req->buf        = NULL;
+
+    /* Find another barrier to merge with. */
+    QSIMPLEQ_FOREACH(section_req, &bq->sections, link_section) {
+        if (section_req->section >= req->section) {
+
+            /*
+             * If acb is set, the intention of the barrier request is to flush
+             * the complete queue and notify the caller when all requests have
+             * been processed. To achieve this, we may only merge with the very
+             * last request in the queue.
+             */
+            if (acb && QTAILQ_NEXT(section_req, link)) {

block-queue.c line 378

Quoted 10 lines
block-queue.c new file +10 -0
+                continue;
+            }
+
+            req->section = section_req->section;
+            context->section = section_req->section + 1;
+            qemu_free(req);
+            req = section_req;
+            goto out;
+        }
+    }

I think the search for an existing barrier should be moved above the req allocation. It's more work to allocate req, do an unnecessary req->section = section_req->section, and then free it again.

Quoted 13 lines
block-queue.c new file +13 -0
+
+    /*
+     * If there wasn't a barrier for the same section yet, insert a new one at
+     * the end.
+     */
+    DPRINTF("queue-ins flush: %p\n", req);
+    QTAILQ_INSERT_TAIL(&bq->queue, req, link);
+    QSIMPLEQ_INSERT_TAIL(&bq->sections, req, link_section);
+    bq->queue_size++;
+    context->section++;
+
+    bq->barriers_submitted++;
+

block-queue.c line 401

Quoted 10 lines
block-queue.c new file +10 -0
+    /*
+     * At this point, req is either the newly inserted request, or a previously
+     * existing barrier with which the current request has been merged.
+     *
+     * Insert the ACB in the list of that request so that the callback is
+     * called when the request has completed.
+     */
+out:
+    if (acb) {
+        QLIST_INSERT_HEAD(&req->acbs, acb, link);

Is there a reason to insert at the head and not append to the tail? Preserving order is usually good.

Quoted 7 lines
block-queue.c new file +7 -0
+/*
+ * If there are any blkqueue_aio_flush callbacks pending, call them with ret
+ * as the error code and remove them from the queue.
+ *
+ * If keep_queue is false, all requests are removed from the queue
+ */
+static void blkqueue_fail_flush(BlockQueue *bq, int ret, bool keep_queue)

block-queue.c line 474

Quoted 10 lines
block-queue.c new file +10 -0
+{
+    BlockQueueRequest *req, *next_req;
+    BlockQueueAIOCB *acb, *next_acb;
+
+    QTAILQ_FOREACH_SAFE(req, &bq->queue, link, next_req) {
+
+        /* Call and remove registered callbacks */
+        QLIST_FOREACH_SAFE(acb, &req->acbs, link, next_acb) {
+            acb->common.cb(acb->common.opaque, ret);
+            qemu_free(acb);

qemu_aio_release()

Quoted 6 lines

+        }
+        QLIST_INIT(&req->acbs);
+
+        /* If requested, remove the request itself */
+        if (!keep_queue) {
+            QTAILQ_REMOVE(&bq->queue, req, link);

bq->queue_size--;

Quoted 4 lines

+            if (req->type == REQ_TYPE_BARRIER) {
+                QSIMPLEQ_REMOVE(&bq->sections, req, BlockQueueRequest,
+                    link_section);
+            }

Now free the request?

Quoted 34 lines

+        }
+    }

block-queue.c new file +32 -0
+
+    /* Make sure that blkqueue_flush stops running */
+    bq->flushing = ret;
+}
+
+static void blkqueue_process_request_cb(void *opaque, int ret)
+{
+    BlockQueueRequest *req = opaque;
+    BlockQueue *bq = req->bq;
+    BlockQueueAIOCB *acb, *next;
+
+    DPRINTF("  done    req:    %p [%#lx + %ld]\n", req, req->offset, req->size);
+
+    /* Remove from in-flight list */
+    QTAILQ_REMOVE(&bq->in_flight, req, link);
+    bq->in_flight_num--;
+
+    /*
+     * Error handling gets a bit complicated, because we have already completed
+     * the requests that went wrong. There are two ways of dealing with this:
+     *
+     * 1. With werror=stop we can put the request back into the queue and stop
+     *    the VM. When the user continues the VM, the request is retried.
+     *
+     * 2. In other cases we need to return an error on the next bdrv_flush. The
+     *    caller must cope with the fact that he doesn't know which of the
+     *    requests succeeded (i.e. invalidate all caches)
+     *
+     * If we're in an blkqueue_aio_flush, we must return an error in both
+     * cases. If we stop the VM, we can clear bq->errno immediately again.
+     * Otherwise, it's cleared in bdrv_(aio_)flush.
+     */

block-queue.c line 528

Quoted 10 lines
block-queue.c new file +10 -0
+    if (ret < 0) {
+        if (bq->error_ret != -ENOSPC) {
+            bq->error_ret = ret;
+        }
+    }
+
+    /* Call any callbacks attached to the request (see blkqueue_aio_flush) */
+    QLIST_FOREACH_SAFE(acb, &req->acbs, link, next) {
+        acb->common.cb(acb->common.opaque, bq->error_ret);
+        qemu_free(acb);

qemu_aio_release()

Quoted 27 lines

+    }
+    QLIST_INIT(&req->acbs);

block-queue.c new file +25 -0
+
+    /* Handle errors in the VM stop case */
+    if (ret < 0) {
+        bool keep_queue = bq->error_handler(bq->error_opaque, ret);
+
+        /* Fail any flushes that may wait for the queue to become empty */
+        blkqueue_fail_flush(bq, bq->error_ret, keep_queue);
+
+        if (keep_queue) {
+            /* Reinsert request into the queue */
+            QTAILQ_INSERT_HEAD(&bq->queue, req, link);
+            if (req->type == REQ_TYPE_BARRIER) {
+                QSIMPLEQ_INSERT_HEAD(&bq->sections, req, link_section);
+            }
+
+            /* Clear the error to restore a normal state after 'cont' */
+            bq->error_ret = 0;
+            return;
+        }
+    }
+
+    /* Cleanup */
+    blkqueue_free_request(req);
+
+    /* Check if there are more requests to submit */

block-queue.c line 565

Quoted 10 lines
block-queue.c new file +10 -0
+    blkqueue_process_request(bq);
+}
+
+/*
+ * Checks if the first request on the queue can run. If so, remove it from the
+ * queue, submit the request and put it onto the queue of in-flight requests.
+ *
+ * Returns 0 if a request has been submitted, -1 if no request can run or an
+ * error has occurred.
+ */

If we want specific error codes:
-EAGAIN no request can run
-EINVAL, -EIO, ... specific errors

Quoted 20 lines
block-queue.c new file +20 -0
+static int blkqueue_submit_request(BlockQueue *bq)
+{
+    BlockDriverAIOCB *acb;
+    BlockQueueRequest *req;
+
+    /*
+     * If we had an error, we must not submit new requests from another
+     * section or may we get ordering problems. In fact, not submitting any new
+     * requests looks like a good idea in this case.
+     */
+    if (bq->error_ret) {
+        return -1;
+    }
+
+    /* Fetch a request */
+    req = QTAILQ_FIRST(&bq->queue);
+    if (req == NULL) {
+        return -1;
+    }
+

block-queue.c line 595

Quoted 10 lines
block-queue.c new file +10 -0
+    /* Writethrough images aren't supposed to have any queue entries */
+    assert((bq->bs->open_flags & WRITEBACK_MODES) != 0);
+
+    /*
+     * We need to wait for completion before we can submit new requests:
+     * 1. If we're currently processing a barrier, or the new request is a
+     *    barrier, we need to guarantee this barrier semantics.
+     * 2. We must make sure that newer writes cannot pass older ones.
+     */
+    if (bq->in_flight_num > 0) {

I don't understand why we refuse to do more work on in_flight_num > 0.
This function increments in_flight_num which means
blkqueue_process_request() will only ever submit one request at a time? Why does blkqueue_process_request() loop then? I'm missing something.

Quoted 8 lines

+        return -1;
+    }
+
+    /* Process barriers only if the queue is long enough */
+    if (!bq->flushing) {
+        if (req->type == REQ_TYPE_BARRIER && bq->queue_size < 50) {
+            return -1;
+        }

Not sure about this. Need to think about the patch more but this check looks like it could have consequences like starvation. I guess that's why you check for !bq->flushing.

block-queue.c line 663

Quoted 10 lines
block-queue.c new file +10 -0
+static void blkqueue_aio_cancel(BlockDriverAIOCB *blockacb)
+{
+    BlockQueueAIOCB *acb = (BlockQueueAIOCB*) blockacb;
+
+    /*
+     * We can't cancel the flush any more, but that doesn't hurt. We just
+     * need to make sure that we don't call the callback when it completes.
+     */
+    QLIST_REMOVE(acb, link);
+    qemu_free(acb);

qemu_aio_release()

Quoted 13 lines
block-queue.c new file +13 -0
+}
+
+/*
+ * Inserts a barrier at the end of the queue (or merges with an existing
+ * barrier there). Once the barrier has completed, the callback is called.
+ */
+BlockDriverAIOCB* blkqueue_aio_flush(BlockQueueContext *context,
+    BlockDriverCompletionFunc *cb, void *opaque)
+{
+    BlockQueueAIOCB *acb;
+    BlockDriverState *bs = context->bq->bs;
+    int ret;
+

block-queue.c line 686

Quoted 10 lines
block-queue.c new file +10 -0
+    /* Don't use the queue for writethrough images */
+    if ((bs->open_flags & WRITEBACK_MODES) == 0) {
+        return bdrv_aio_flush(bs, cb, opaque);
+    }
+
+    /* Insert a barrier into the queue */
+    acb = qemu_aio_get(&blkqueue_aio_pool, NULL, cb, opaque);
+
+    ret = insert_barrier(context, acb);
+    if (ret < 0) {

This return path is broken:

Quoted 1 line

+        cb(opaque, ret);

Missing BH.

Quoted 1 line

+        qemu_free(acb);

qemu_aio_release(acb);

If we want to invoke cb (via a BH) then we shouldn't release acb. If we do release it we need to return NULL but shouldn't invoke cb.

Quoted 27 lines

+    }

block-queue.c new file +26 -0
+
+    return &acb->common;
+}
+
+/*
+ * Flushes the queue (i.e. disables waiting for new requests to be batched) and
+ * waits until all requests in the queue have completed.
+ *
+ * Note that unlike blkqueue_aio_flush this does not call bdrv_flush().
+ */
+int blkqueue_flush(BlockQueue *bq)
+{
+    int res = 0;
+
+    bq->flushing = 1;
+
+    /* Process any left over requests */
+    while ((bq->flushing > 0) &&
+        (bq->in_flight_num || QTAILQ_FIRST(&bq->queue)))
+    {
+        blkqueue_process_request(bq);
+        qemu_aio_wait();
+    }
+
+    /*
+     * bq->flushing contains the error if it could be handled by stopping the

block-queue.c line 725

Quoted 10 lines
block-queue.c new file +10 -0
+     * VM, error_ret contains it if we're not allowed to do this.
+     */
+    if (bq->error_ret < 0) {
+        res = bq->error_ret;
+
+        /*
+         * Wait for AIO requests, so that the queue is really unused after
+         * blkqueue_flush() and the caller can destroy it
+         */
+        if (res < 0) {

We already know bq->error_ret < 0. This comparison is always true.

Stefan

author
#7 lore raw

RFC PATCH v3 3/4 Test cases for block-queue

In reply to Kevin Wolf

Add some unit tests especially for the ordering and request merging in block-queue.

---
 Makefile            |    1 +
 check-block-queue.c |  402 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 403 insertions(+), 0 deletions(-)
 create mode 100644 check-block-queue.c
Makefile +1 -0
index 4e120a2..3e7071c 100644
@@ -171,6 +171,7 @@ check-qdict: check-qdict.o qdict.o qfloat.o qint.o qstring.o qbool.o qlist.o $(C
 check-qlist: check-qlist.o qlist.o qint.o $(CHECK_PROG_DEPS)
 check-qfloat: check-qfloat.o qfloat.o $(CHECK_PROG_DEPS)
 check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o $(CHECK_PROG_DEPS)
+check-block-queue: check-block-queue.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(filter-out block-queue.o,$(block-obj-y)) $(qobject-obj-y) qemu-timer-common.o
 
 clean:
 # avoid old build problems by removing potentially incorrect old files
check-block-queue.c new file +402 -0

402 lines not on this page · raw message

Signature · 1 line
1.7.2.3
author
#8 lore raw

RFC PATCH v3 4/4 qcow2: Preliminary block-queue support

In reply to Kevin Wolf

This is a first hack that makes qcow2 use block-queue. Will be reworked to pass down the blkqueue context to all functions that queue requests instead of using a global per-image context.

---
 block/qcow2-cluster.c  |   39 +++++++++++-----------
 block/qcow2-refcount.c |   62 ++++++++++++++++++------------------
 block/qcow2.c          |   83 +++++++++++++++++++++++++++++++++++++++++++++++-
 block/qcow2.h          |    5 +++
 cpus.c                 |    8 +++--
 qemu-common.h          |    3 ++
 qemu-tool.c            |    5 +++
 sysemu.h               |    1 -
 8 files changed, 151 insertions(+), 55 deletions(-)
block/qcow2-cluster.c +20 -19
index b040208..674699d 100644
@@ -67,12 +67,13 @@ int qcow2_grow_l1_table(BlockDriverState *bs, int min_size, bool exact_size)
         qemu_free(new_l1_table);
         return new_l1_table_offset;
     }
-    bdrv_flush(bs->file);
+    blkqueue_barrier(s->bq_context);
 
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);
     for(i = 0; i < s->l1_size; i++)
         new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
-    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_table, new_l1_size2);
+    ret = blkqueue_pwrite(s->bq_context, new_l1_table_offset, new_l1_table, new_l1_size2);
+    blkqueue_barrier(s->bq_context);
     if (ret < 0)
         goto fail;
     for(i = 0; i < s->l1_size; i++)
@@ -82,7 +83,8 @@ int qcow2_grow_l1_table(BlockDriverState *bs, int min_size, bool exact_size)
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
     cpu_to_be32w((uint32_t*)data, new_l1_size);
     cpu_to_be64w((uint64_t*)(data + 4), new_l1_table_offset);
-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size), data,sizeof(data));
+    ret = blkqueue_pwrite(s->bq_context, offsetof(QCowHeader, l1_size), data, sizeof(data));
+    blkqueue_barrier(s->bq_context);
     if (ret < 0) {
         goto fail;
     }
@@ -185,8 +187,7 @@ static int l2_load(BlockDriverState *bs, uint64_t l2_offset,
     *l2_table = s->l2_cache + (min_index << s->l2_bits);
 
     BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
-    ret = bdrv_pread(bs->file, l2_offset, *l2_table,
-        s->l2_size * sizeof(uint64_t));
+    ret = blkqueue_pread(s->bq_context, l2_offset, *l2_table, s->l2_size * sizeof(uint64_t));
     if (ret < 0) {
         qcow2_l2_cache_reset(bs);
         return ret;
@@ -216,8 +217,8 @@ static int write_l1_entry(BlockDriverState *bs, int l1_index)
     }
 
     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
-    ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset + 8 * l1_start_index,
-        buf, sizeof(buf));
+    ret = blkqueue_pwrite(s->bq_context, s->l1_table_offset + 8 * l1_start_index, buf, sizeof(buf));
+    blkqueue_barrier(s->bq_context);
     if (ret < 0) {
         return ret;
     }
@@ -252,7 +253,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
     if (l2_offset < 0) {
         return l2_offset;
     }
-    bdrv_flush(bs->file);
+    blkqueue_barrier(s->bq_context);
 
     /* allocate a new entry in the l2 cache */
 
@@ -265,16 +266,15 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
     } else {
         /* if there was an old l2 table, read it from the disk */
         BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_COW_READ);
-        ret = bdrv_pread(bs->file, old_l2_offset, l2_table,
-            s->l2_size * sizeof(uint64_t));
+        ret = blkqueue_pread(s->bq_context, old_l2_offset, l2_table, s->l2_size * sizeof(uint64_t));
         if (ret < 0) {
             goto fail;
         }
     }
     /* write the l2 table to the file */
     BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_WRITE);
-    ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
-        s->l2_size * sizeof(uint64_t));
+    ret = blkqueue_pwrite(s->bq_context, l2_offset, l2_table, s->l2_size * sizeof(uint64_t));
+    blkqueue_barrier(s->bq_context);
     if (ret < 0) {
         goto fail;
     }
@@ -394,8 +394,8 @@ static int qcow_read(BlockDriverState *bs, int64_t sector_num,
             memcpy(buf, s->cluster_cache + index_in_cluster * 512, 512 * n);
         } else {
             BLKDBG_EVENT(bs->file, BLKDBG_READ);
-            ret = bdrv_pread(bs->file, cluster_offset + index_in_cluster * 512, buf, n * 512);
-            if (ret != n * 512)
+            ret = blkqueue_pread(s->bq_context, cluster_offset + index_in_cluster * 512, buf, n * 512);
+            if (ret < 0)
                 return -1;
             if (s->crypt_method) {
                 qcow2_encrypt_sectors(s, sector_num, buf, buf, n, 0,
@@ -647,11 +647,12 @@ uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
 
     BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
     l2_table[l2_index] = cpu_to_be64(cluster_offset);
-    if (bdrv_pwrite_sync(bs->file,
+    if (blkqueue_pwrite(s->bq_context,
                     l2_offset + l2_index * sizeof(uint64_t),
                     l2_table + l2_index,
                     sizeof(uint64_t)) < 0)
         return 0;
+    blkqueue_barrier(s->bq_context);
 
     return cluster_offset;
 }
@@ -664,6 +665,7 @@ uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
 static int write_l2_entries(BlockDriverState *bs, uint64_t *l2_table,
     uint64_t l2_offset, int l2_index, int num)
 {
+    BDRVQcowState *s = bs->opaque;
     int l2_start_index = l2_index & ~(L1_ENTRIES_PER_SECTOR - 1);
     int start_offset = (8 * l2_index) & ~511;
     int end_offset = (8 * (l2_index + num) + 511) & ~511;
@@ -671,8 +673,7 @@ static int write_l2_entries(BlockDriverState *bs, uint64_t *l2_table,
     int ret;
 
     BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
-    ret = bdrv_pwrite(bs->file, l2_offset + start_offset,
-        &l2_table[l2_start_index], len);
+    ret = blkqueue_pwrite(s->bq_context, l2_offset + start_offset, &l2_table[l2_start_index], len);
     if (ret < 0) {
         return ret;
     }
@@ -733,7 +734,7 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
      * need to be sure that the refcounts have been increased and COW was
      * handled.
      */
-    bdrv_flush(bs->file);
+    blkqueue_barrier(s->bq_context);
 
     ret = write_l2_entries(bs, l2_table, l2_offset, l2_index, m->nb_clusters);
     if (ret < 0) {
@@ -746,7 +747,7 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
      * Also flush bs->file to get the right order for L2 and refcount update.
      */
     if (j != 0) {
-        bdrv_flush(bs->file);
+        blkqueue_barrier(s->bq_context);
         for (i = 0; i < j; i++) {
             qcow2_free_any_clusters(bs,
                 be64_to_cpu(old_cluster[i]) & ~QCOW_OFLAG_COPIED, 1);
block/qcow2-refcount.c +31 -31

188 lines not on this page · raw message

block/qcow2.c +82 -1

143 lines not on this page · raw message

block/qcow2.h +5 -0
index 2d22e5e..2ef910c 100644
@@ -26,6 +26,7 @@
 #define BLOCK_QCOW2_H
 
 #include "aes.h"
+#include "block-queue.h"
 
 //#define DEBUG_ALLOC
 //#define DEBUG_ALLOC2
@@ -108,6 +109,10 @@ typedef struct BDRVQcowState {
     int64_t free_cluster_index;
     int64_t free_byte_offset;
 
+    BlockQueue *bq;
+    BlockQueueContext *bq_context;
+    BlockQueueContext initial_bq_context;
+
     uint32_t crypt_method; /* current crypt method, 0 if no key yet */
     uint32_t crypt_method_header;
     AES_KEY aes_encrypt_key;
cpus.c +5 -3
index 91a0fb1..8ec0ed6 100644
@@ -310,9 +310,10 @@ void qemu_notify_event(void)
 void qemu_mutex_lock_iothread(void) {}
 void qemu_mutex_unlock_iothread(void) {}
 
-void vm_stop(int reason)
+bool vm_stop(int reason)
 {
     do_vm_stop(reason);
+    return true;
 }
 
 #else /* CONFIG_IOTHREAD */
@@ -848,7 +849,7 @@ static void qemu_system_vmstop_request(int reason)
     qemu_notify_event();
 }
 
-void vm_stop(int reason)
+bool vm_stop(int reason)
 {
     QemuThread me;
     qemu_thread_self(&me);
@@ -863,9 +864,10 @@ void vm_stop(int reason)
             cpu_exit(cpu_single_env);
             cpu_single_env->stop = 1;
         }
-        return;
+        return true;
     }
     do_vm_stop(reason);
+    return true;
 }
 
 #endif
qemu-common.h +3 -0
index b3957f1..1c23b0f 100644
@@ -115,6 +115,9 @@ static inline char *realpath(const char *path, char *resolved_path)
 
 #endif /* !defined(NEED_CPU_H) */
 
+/* VM state */
+bool vm_stop(int reason);
+
 /* bottom halves */
 typedef void QEMUBHFunc(void *opaque);
 
qemu-tool.c +5 -0
index 392e1c9..3926435 100644
@@ -111,3 +111,8 @@ int qemu_set_fd_handler2(int fd,
 {
     return 0;
 }
+
+bool vm_stop(int reason)
+{
+    return false;
+}
sysemu.h +0 -1
index b81a70e..77788f1 100644
@@ -38,7 +38,6 @@ VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
 
 void vm_start(void);
-void vm_stop(int reason);
 
 uint64_t ram_bytes_remaining(void);
 uint64_t ram_bytes_transferred(void);
Signature · 1 line
1.7.2.3