Commit 380f649e authored by Peter Maydell's avatar Peter Maydell
Browse files

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



# gpg: Signature made Mon 22 Sep 2014 12:41:59 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: (59 commits)
  block: Always compile virtio-blk dataplane
  vring: Better error handling if num is too large
  virtio: Import virtio_vring.h
  async: aio_context_new(): Handle event_notifier_init failure
  block: vhdx - fix reading beyond pointer during image creation
  block: delete cow block driver
  block/archipelago: Fix typo in qemu_archipelago_truncate()
  ahci: Add test_identify case to ahci-test.
  ahci: Add test_hba_enable to ahci-test.
  ahci: Add test_hba_spec to ahci-test.
  ahci: properly shadow the TFD register
  ahci: add test_pci_enable to ahci-test.
  ahci: Add test_pci_spec to ahci-test.
  ahci: MSI capability should be at 0x80, not 0x50.
  ahci: Adding basic functionality qtest.
  layout: Add generators for refcount table and blocks
  fuzz: Add fuzzing functions for entries of refcount table and blocks
  docs: List all image elements currently supported by the fuzzer
  qapi/block-core: Add "new" qcow2 options
  qcow2: Add overlap-check.template option
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 17336812 52b53c04

aio-win32.c

+3 −5
Original line number Diff line number Diff line
@@ -283,9 +283,9 @@ bool aio_poll(AioContext *ctx, bool blocking) 
    int count;

    int timeout;



    if (aio_prepare(ctx)) {

    have_select_revents = aio_prepare(ctx);

    if (have_select_revents) {

        blocking = false;

        have_select_revents = true;

    }



    was_dispatching = ctx->dispatching;
@@ -335,6 +335,7 @@ bool aio_poll(AioContext *ctx, bool blocking) 
        event = NULL;

        if ((DWORD) (ret - WAIT_OBJECT_0) < count) {

            event = events[ret - WAIT_OBJECT_0];

            events[ret - WAIT_OBJECT_0] = events[--count];

        } else if (!have_select_revents) {

            break;

        }
@@ -343,9 +344,6 @@ bool aio_poll(AioContext *ctx, bool blocking) 
        blocking = false;



        progress |= aio_dispatch_handlers(ctx, event);



        /* Try again, but only call each handler once.  */

        events[ret - WAIT_OBJECT_0] = events[--count];

    }



    progress |= timerlistgroup_run_timers(&ctx->tlg);

async.c

+11 −5
Original line number Diff line number Diff line
@@ -289,18 +289,24 @@ static void aio_rfifolock_cb(void *opaque) 
    aio_notify(opaque);

}



AioContext *aio_context_new(void)

AioContext *aio_context_new(Error **errp)

{

    int ret;

    AioContext *ctx;

    ctx = (AioContext *) g_source_new(&aio_source_funcs, sizeof(AioContext));

    ret = event_notifier_init(&ctx->notifier, false);

    if (ret < 0) {

        g_source_destroy(&ctx->source);

        error_setg_errno(errp, -ret, "Failed to initialize event notifier");

        return NULL;

    }

    aio_set_event_notifier(ctx, &ctx->notifier,

                           (EventNotifierHandler *)

                           event_notifier_test_and_clear);

    ctx->pollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD));

    ctx->thread_pool = NULL;

    qemu_mutex_init(&ctx->bh_lock);

    rfifolock_init(&ctx->lock, aio_rfifolock_cb, ctx);

    event_notifier_init(&ctx->notifier, false);

    aio_set_event_notifier(ctx, &ctx->notifier, 

                           (EventNotifierHandler *)

                           event_notifier_test_and_clear);

    timerlistgroup_init(&ctx->tlg, aio_timerlist_notify, ctx);



    return ctx;

block.c

+36 −36
Original line number Diff line number Diff line
@@ -4640,7 +4640,28 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) 


void bdrv_aio_cancel(BlockDriverAIOCB *acb)

{

    acb->aiocb_info->cancel(acb);

    qemu_aio_ref(acb);

    bdrv_aio_cancel_async(acb);

    while (acb->refcnt > 1) {

        if (acb->aiocb_info->get_aio_context) {

            aio_poll(acb->aiocb_info->get_aio_context(acb), true);

        } else if (acb->bs) {

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

        } else {

            abort();

        }

    }

    qemu_aio_unref(acb);

}



/* Async version of aio cancel. The caller is not blocked if the acb implements

 * cancel_async, otherwise we do nothing and let the request normally complete.

 * In either case the completion callback must be called. */

void bdrv_aio_cancel_async(BlockDriverAIOCB *acb)

{

    if (acb->aiocb_info->cancel_async) {

        acb->aiocb_info->cancel_async(acb);

    }

}



/**************************************************************/
@@ -4656,18 +4677,8 @@ typedef struct BlockDriverAIOCBSync { 
    int is_write;

} BlockDriverAIOCBSync;



static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)

{

    BlockDriverAIOCBSync *acb =

        container_of(blockacb, BlockDriverAIOCBSync, common);

    qemu_bh_delete(acb->bh);

    acb->bh = NULL;

    qemu_aio_release(acb);

}



static const AIOCBInfo bdrv_em_aiocb_info = {

    .aiocb_size         = sizeof(BlockDriverAIOCBSync),

    .cancel             = bdrv_aio_cancel_em,

};



static void bdrv_aio_bh_cb(void *opaque)
@@ -4681,7 +4692,7 @@ static void bdrv_aio_bh_cb(void *opaque) 
    acb->common.cb(acb->common.opaque, acb->ret);

    qemu_bh_delete(acb->bh);

    acb->bh = NULL;

    qemu_aio_release(acb);

    qemu_aio_unref(acb);

}



static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
@@ -4738,22 +4749,8 @@ typedef struct BlockDriverAIOCBCoroutine { 
    QEMUBH* bh;

} BlockDriverAIOCBCoroutine;



static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)

{

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

    BlockDriverAIOCBCoroutine *acb =

        container_of(blockacb, BlockDriverAIOCBCoroutine, common);

    bool done = false;



    acb->done = &done;

    while (!done) {

        aio_poll(aio_context, true);

    }

}



static const AIOCBInfo bdrv_em_co_aiocb_info = {

    .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),

    .cancel             = bdrv_aio_co_cancel_em,

};



static void bdrv_co_em_bh(void *opaque)
@@ -4762,12 +4759,8 @@ static void bdrv_co_em_bh(void *opaque) 


    acb->common.cb(acb->common.opaque, acb->req.error);



    if (acb->done) {

        *acb->done = true;

    }



    qemu_bh_delete(acb->bh);

    qemu_aio_release(acb);

    qemu_aio_unref(acb);

}



/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
@@ -4806,7 +4799,6 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, 
    acb->req.qiov = qiov;

    acb->req.flags = flags;

    acb->is_write = is_write;

    acb->done = NULL;



    co = qemu_coroutine_create(bdrv_co_do_rw);

    qemu_coroutine_enter(co, acb);
@@ -4833,7 +4825,6 @@ BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, 
    BlockDriverAIOCBCoroutine *acb;



    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);

    acb->done = NULL;



    co = qemu_coroutine_create(bdrv_aio_flush_co_entry);

    qemu_coroutine_enter(co, acb);
@@ -4863,7 +4854,6 @@ BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs, 
    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);

    acb->req.sector = sector_num;

    acb->req.nb_sectors = nb_sectors;

    acb->done = NULL;

    co = qemu_coroutine_create(bdrv_aio_discard_co_entry);

    qemu_coroutine_enter(co, acb);
@@ -4891,14 +4881,24 @@ void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, 
    acb->bs = bs;

    acb->cb = cb;

    acb->opaque = opaque;

    acb->refcnt = 1;

    return acb;

}



void qemu_aio_release(void *p)

void qemu_aio_ref(void *p)

{

    BlockDriverAIOCB *acb = p;

    acb->refcnt++;

}



void qemu_aio_unref(void *p)

{

    BlockDriverAIOCB *acb = p;

    assert(acb->refcnt > 0);

    if (--acb->refcnt == 0) {

        g_slice_free1(acb->aiocb_info->aiocb_size, acb);

    }

}



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

/* Coroutine block device emulation */

block/Makefile.objs

+2 −1
Original line number Diff line number Diff line 
block-obj-y += raw_bsd.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat.o

block-obj-y += raw_bsd.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat.o

block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o

block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o

block-obj-y += qed-check.o
@@ -9,6 +9,7 @@ block-obj-y += snapshot.o qapi.o 
block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o

block-obj-$(CONFIG_POSIX) += raw-posix.o

block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o

block-obj-y += null.o



block-obj-y += nbd.o nbd-client.o sheepdog.o

block-obj-$(CONFIG_LIBISCSI) += iscsi.o

block/archipelago.c

+3 −18
Original line number Diff line number Diff line
@@ -91,7 +91,6 @@ typedef struct ArchipelagoAIOCB { 
    struct BDRVArchipelagoState *s;

    QEMUIOVector *qiov;

    ARCHIPCmd cmd;

    bool cancelled;

    int status;

    int64_t size;

    int64_t ret;
@@ -318,9 +317,7 @@ static void qemu_archipelago_complete_aio(void *opaque) 
    aio_cb->common.cb(aio_cb->common.opaque, aio_cb->ret);

    aio_cb->status = 0;



    if (!aio_cb->cancelled) {

        qemu_aio_release(aio_cb);

    }

    qemu_aio_unref(aio_cb);

    g_free(reqdata);

}
@@ -725,19 +722,8 @@ static int qemu_archipelago_create(const char *filename, 
    return ret;

}



static void qemu_archipelago_aio_cancel(BlockDriverAIOCB *blockacb)

{

    ArchipelagoAIOCB *aio_cb = (ArchipelagoAIOCB *) blockacb;

    aio_cb->cancelled = true;

    while (aio_cb->status == -EINPROGRESS) {

        aio_poll(bdrv_get_aio_context(aio_cb->common.bs), true);

    }

    qemu_aio_release(aio_cb);

}



static const AIOCBInfo archipelago_aiocb_info = {

    .aiocb_size = sizeof(ArchipelagoAIOCB),

    .cancel = qemu_archipelago_aio_cancel,

};



static int archipelago_submit_request(BDRVArchipelagoState *s,
@@ -889,7 +875,6 @@ static BlockDriverAIOCB *qemu_archipelago_aio_rw(BlockDriverState *bs, 


    aio_cb->ret = 0;

    aio_cb->s = s;

    aio_cb->cancelled = false;

    aio_cb->status = -EINPROGRESS;



    off = sector_num * BDRV_SECTOR_SIZE;
@@ -905,7 +890,7 @@ static BlockDriverAIOCB *qemu_archipelago_aio_rw(BlockDriverState *bs, 


err_exit:

    error_report("qemu_archipelago_aio_rw(): I/O Error\n");

    qemu_aio_release(aio_cb);

    qemu_aio_unref(aio_cb);

    return NULL;

}
@@ -1008,7 +993,7 @@ static int qemu_archipelago_truncate(BlockDriverState *bs, int64_t offset) 
    req = xseg_get_request(s->xseg, s->srcport, s->mportno, X_ALLOC);

    if (!req) {

        archipelagolog("Cannot get XSEG request\n");

        return err_exit2;

        goto err_exit2;

    }



    ret = xseg_prep_request(s->xseg, req, targetlen, 0);