2016-03-14 08:45:10 +01:00
|
|
|
/*
|
|
|
|
* Block protocol for record/replay
|
|
|
|
*
|
|
|
|
* Copyright (c) 2010-2016 Institute for System Programming
|
|
|
|
* of the Russian Academy of Sciences.
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "block/block_int.h"
|
|
|
|
#include "sysemu/replay.h"
|
|
|
|
#include "qapi/error.h"
|
|
|
|
|
|
|
|
typedef struct Request {
|
|
|
|
Coroutine *co;
|
|
|
|
QEMUBH *bh;
|
|
|
|
} Request;
|
|
|
|
|
|
|
|
/* Next request id.
|
|
|
|
This counter is global, because requests from different
|
|
|
|
block devices should not get overlapping ids. */
|
|
|
|
static uint64_t request_id;
|
|
|
|
|
|
|
|
static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Open the image file */
|
|
|
|
bs->file = bdrv_open_child(NULL, options, "image",
|
|
|
|
bs, &child_file, false, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
fail:
|
|
|
|
if (ret < 0) {
|
|
|
|
bdrv_unref_child(bs, bs->file);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void blkreplay_close(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t blkreplay_getlength(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
return bdrv_getlength(bs->file->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This bh is used for synchronization of return from coroutines.
|
|
|
|
It continues yielded coroutine which then finishes its execution.
|
|
|
|
BH is called adjusted to some replay checkpoint, therefore
|
|
|
|
record and replay will always finish coroutines deterministically.
|
|
|
|
*/
|
|
|
|
static void blkreplay_bh_cb(void *opaque)
|
|
|
|
{
|
|
|
|
Request *req = opaque;
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 19:10:01 +02:00
|
|
|
qemu_coroutine_enter(req->co);
|
2016-03-14 08:45:10 +01:00
|
|
|
qemu_bh_delete(req->bh);
|
|
|
|
g_free(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_request_create(uint64_t reqid, BlockDriverState *bs,
|
|
|
|
Coroutine *co)
|
|
|
|
{
|
|
|
|
Request *req = g_new(Request, 1);
|
|
|
|
*req = (Request) {
|
|
|
|
.co = co,
|
|
|
|
.bh = aio_bh_new(bdrv_get_aio_context(bs), blkreplay_bh_cb, req),
|
|
|
|
};
|
|
|
|
replay_block_event(req->bh, reqid);
|
|
|
|
}
|
|
|
|
|
2016-05-30 14:31:59 +02:00
|
|
|
static int coroutine_fn blkreplay_co_preadv(BlockDriverState *bs,
|
|
|
|
uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags)
|
2016-03-14 08:45:10 +01:00
|
|
|
{
|
|
|
|
uint64_t reqid = request_id++;
|
2016-06-20 21:31:46 +02:00
|
|
|
int ret = bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
|
2016-03-14 08:45:10 +01:00
|
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-30 14:31:59 +02:00
|
|
|
static int coroutine_fn blkreplay_co_pwritev(BlockDriverState *bs,
|
|
|
|
uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags)
|
2016-03-14 08:45:10 +01:00
|
|
|
{
|
|
|
|
uint64_t reqid = request_id++;
|
2016-06-20 21:31:46 +02:00
|
|
|
int ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
|
2016-03-14 08:45:10 +01:00
|
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-06-01 23:10:07 +02:00
|
|
|
static int coroutine_fn blkreplay_co_pwrite_zeroes(BlockDriverState *bs,
|
|
|
|
int64_t offset, int count, BdrvRequestFlags flags)
|
2016-03-14 08:45:10 +01:00
|
|
|
{
|
|
|
|
uint64_t reqid = request_id++;
|
2016-06-20 21:31:46 +02:00
|
|
|
int ret = bdrv_co_pwrite_zeroes(bs->file, offset, count, flags);
|
2016-03-14 08:45:10 +01:00
|
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn blkreplay_co_discard(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors)
|
|
|
|
{
|
|
|
|
uint64_t reqid = request_id++;
|
|
|
|
int ret = bdrv_co_discard(bs->file->bs, sector_num, nb_sectors);
|
|
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn blkreplay_co_flush(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
uint64_t reqid = request_id++;
|
|
|
|
int ret = bdrv_co_flush(bs->file->bs);
|
|
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BlockDriver bdrv_blkreplay = {
|
|
|
|
.format_name = "blkreplay",
|
|
|
|
.protocol_name = "blkreplay",
|
|
|
|
.instance_size = 0,
|
|
|
|
|
|
|
|
.bdrv_file_open = blkreplay_open,
|
|
|
|
.bdrv_close = blkreplay_close,
|
|
|
|
.bdrv_getlength = blkreplay_getlength,
|
|
|
|
|
2016-05-30 14:31:59 +02:00
|
|
|
.bdrv_co_preadv = blkreplay_co_preadv,
|
|
|
|
.bdrv_co_pwritev = blkreplay_co_pwritev,
|
2016-03-14 08:45:10 +01:00
|
|
|
|
2016-06-01 23:10:07 +02:00
|
|
|
.bdrv_co_pwrite_zeroes = blkreplay_co_pwrite_zeroes,
|
2016-03-14 08:45:10 +01:00
|
|
|
.bdrv_co_discard = blkreplay_co_discard,
|
|
|
|
.bdrv_co_flush = blkreplay_co_flush,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void bdrv_blkreplay_init(void)
|
|
|
|
{
|
|
|
|
bdrv_register(&bdrv_blkreplay);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_init(bdrv_blkreplay_init);
|