block: generate coroutine-wrapper code
Use code generation implemented in previous commit to generated coroutine wrappers in block.c and block/io.c Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> Reviewed-by: Eric Blake <eblake@redhat.com> Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com> Message-Id: <20200924185414.28642-6-vsementsov@virtuozzo.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy
Stefan Hajnoczi
parent
aaaa20b69b
commit
9bb4b066cc
73
block.c
73
block.c
@ -4691,43 +4691,6 @@ int coroutine_fn bdrv_co_check(BlockDriverState *bs,
|
||||
return bs->drv->bdrv_co_check(bs, res, fix);
|
||||
}
|
||||
|
||||
typedef struct CheckCo {
|
||||
BlockDriverState *bs;
|
||||
BdrvCheckResult *res;
|
||||
BdrvCheckMode fix;
|
||||
int ret;
|
||||
} CheckCo;
|
||||
|
||||
static void coroutine_fn bdrv_check_co_entry(void *opaque)
|
||||
{
|
||||
CheckCo *cco = opaque;
|
||||
cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix);
|
||||
aio_wait_kick();
|
||||
}
|
||||
|
||||
int bdrv_check(BlockDriverState *bs,
|
||||
BdrvCheckResult *res, BdrvCheckMode fix)
|
||||
{
|
||||
Coroutine *co;
|
||||
CheckCo cco = {
|
||||
.bs = bs,
|
||||
.res = res,
|
||||
.ret = -EINPROGRESS,
|
||||
.fix = fix,
|
||||
};
|
||||
|
||||
if (qemu_in_coroutine()) {
|
||||
/* Fast-path if already in coroutine context */
|
||||
bdrv_check_co_entry(&cco);
|
||||
} else {
|
||||
co = qemu_coroutine_create(bdrv_check_co_entry, &cco);
|
||||
bdrv_coroutine_enter(bs, co);
|
||||
BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS);
|
||||
}
|
||||
|
||||
return cco.ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return values:
|
||||
* 0 - success
|
||||
@ -5860,42 +5823,6 @@ int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp)
|
||||
return 0;
|
||||
}
|
||||
|
||||
typedef struct InvalidateCacheCo {
|
||||
BlockDriverState *bs;
|
||||
Error **errp;
|
||||
bool done;
|
||||
int ret;
|
||||
} InvalidateCacheCo;
|
||||
|
||||
static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque)
|
||||
{
|
||||
InvalidateCacheCo *ico = opaque;
|
||||
ico->ret = bdrv_co_invalidate_cache(ico->bs, ico->errp);
|
||||
ico->done = true;
|
||||
aio_wait_kick();
|
||||
}
|
||||
|
||||
int bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
|
||||
{
|
||||
Coroutine *co;
|
||||
InvalidateCacheCo ico = {
|
||||
.bs = bs,
|
||||
.done = false,
|
||||
.errp = errp
|
||||
};
|
||||
|
||||
if (qemu_in_coroutine()) {
|
||||
/* Fast-path if already in coroutine context */
|
||||
bdrv_invalidate_cache_co_entry(&ico);
|
||||
} else {
|
||||
co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico);
|
||||
bdrv_coroutine_enter(bs, co);
|
||||
BDRV_POLL_WHILE(bs, !ico.done);
|
||||
}
|
||||
|
||||
return ico.ret;
|
||||
}
|
||||
|
||||
void bdrv_invalidate_cache_all(Error **errp)
|
||||
{
|
||||
BlockDriverState *bs;
|
||||
|
||||
@ -34,7 +34,7 @@ int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp);
|
||||
int coroutine_fn
|
||||
bdrv_co_prwv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov,
|
||||
bool is_write, BdrvRequestFlags flags);
|
||||
int
|
||||
int generated_co_wrapper
|
||||
bdrv_prwv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov,
|
||||
bool is_write, BdrvRequestFlags flags);
|
||||
|
||||
@ -47,7 +47,7 @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
|
||||
int64_t *pnum,
|
||||
int64_t *map,
|
||||
BlockDriverState **file);
|
||||
int
|
||||
int generated_co_wrapper
|
||||
bdrv_common_block_status_above(BlockDriverState *bs,
|
||||
BlockDriverState *base,
|
||||
bool want_zero,
|
||||
@ -60,7 +60,7 @@ bdrv_common_block_status_above(BlockDriverState *bs,
|
||||
int coroutine_fn
|
||||
bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
|
||||
bool is_read);
|
||||
int
|
||||
int generated_co_wrapper
|
||||
bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
|
||||
bool is_read);
|
||||
|
||||
|
||||
212
block/io.c
212
block/io.c
@ -890,50 +890,6 @@ static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
|
||||
return 0;
|
||||
}
|
||||
|
||||
typedef int coroutine_fn BdrvRequestEntry(void *opaque);
|
||||
typedef struct BdrvRunCo {
|
||||
BdrvRequestEntry *entry;
|
||||
void *opaque;
|
||||
int ret;
|
||||
bool done;
|
||||
Coroutine *co; /* Coroutine, running bdrv_run_co_entry, for debugging */
|
||||
} BdrvRunCo;
|
||||
|
||||
static void coroutine_fn bdrv_run_co_entry(void *opaque)
|
||||
{
|
||||
BdrvRunCo *arg = opaque;
|
||||
|
||||
arg->ret = arg->entry(arg->opaque);
|
||||
arg->done = true;
|
||||
aio_wait_kick();
|
||||
}
|
||||
|
||||
static int bdrv_run_co(BlockDriverState *bs, BdrvRequestEntry *entry,
|
||||
void *opaque)
|
||||
{
|
||||
if (qemu_in_coroutine()) {
|
||||
/* Fast-path if already in coroutine context */
|
||||
return entry(opaque);
|
||||
} else {
|
||||
BdrvRunCo s = { .entry = entry, .opaque = opaque };
|
||||
|
||||
s.co = qemu_coroutine_create(bdrv_run_co_entry, &s);
|
||||
bdrv_coroutine_enter(bs, s.co);
|
||||
|
||||
BDRV_POLL_WHILE(bs, !s.done);
|
||||
|
||||
return s.ret;
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct RwCo {
|
||||
BdrvChild *child;
|
||||
int64_t offset;
|
||||
QEMUIOVector *qiov;
|
||||
bool is_write;
|
||||
BdrvRequestFlags flags;
|
||||
} RwCo;
|
||||
|
||||
int coroutine_fn bdrv_co_prwv(BdrvChild *child, int64_t offset,
|
||||
QEMUIOVector *qiov, bool is_write,
|
||||
BdrvRequestFlags flags)
|
||||
@ -945,32 +901,6 @@ int coroutine_fn bdrv_co_prwv(BdrvChild *child, int64_t offset,
|
||||
}
|
||||
}
|
||||
|
||||
static int coroutine_fn bdrv_rw_co_entry(void *opaque)
|
||||
{
|
||||
RwCo *rwco = opaque;
|
||||
|
||||
return bdrv_co_prwv(rwco->child, rwco->offset, rwco->qiov,
|
||||
rwco->is_write, rwco->flags);
|
||||
}
|
||||
|
||||
/*
|
||||
* Process a vectored synchronous request using coroutines
|
||||
*/
|
||||
int bdrv_prwv(BdrvChild *child, int64_t offset,
|
||||
QEMUIOVector *qiov, bool is_write,
|
||||
BdrvRequestFlags flags)
|
||||
{
|
||||
RwCo rwco = {
|
||||
.child = child,
|
||||
.offset = offset,
|
||||
.qiov = qiov,
|
||||
.is_write = is_write,
|
||||
.flags = flags,
|
||||
};
|
||||
|
||||
return bdrv_run_co(child->bs, bdrv_rw_co_entry, &rwco);
|
||||
}
|
||||
|
||||
int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
|
||||
int bytes, BdrvRequestFlags flags)
|
||||
{
|
||||
@ -2247,18 +2177,6 @@ int bdrv_flush_all(void)
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
typedef struct BdrvCoBlockStatusData {
|
||||
BlockDriverState *bs;
|
||||
BlockDriverState *base;
|
||||
bool want_zero;
|
||||
int64_t offset;
|
||||
int64_t bytes;
|
||||
int64_t *pnum;
|
||||
int64_t *map;
|
||||
BlockDriverState **file;
|
||||
} BdrvCoBlockStatusData;
|
||||
|
||||
/*
|
||||
* Returns the allocation status of the specified sectors.
|
||||
* Drivers not implementing the functionality are assumed to not support
|
||||
@ -2494,43 +2412,6 @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Coroutine wrapper for bdrv_block_status_above() */
|
||||
static int coroutine_fn bdrv_block_status_above_co_entry(void *opaque)
|
||||
{
|
||||
BdrvCoBlockStatusData *data = opaque;
|
||||
|
||||
return bdrv_co_common_block_status_above(data->bs, data->base,
|
||||
data->want_zero,
|
||||
data->offset, data->bytes,
|
||||
data->pnum, data->map, data->file);
|
||||
}
|
||||
|
||||
/*
|
||||
* Synchronous wrapper around bdrv_co_block_status_above().
|
||||
*
|
||||
* See bdrv_co_block_status_above() for details.
|
||||
*/
|
||||
int bdrv_common_block_status_above(BlockDriverState *bs,
|
||||
BlockDriverState *base,
|
||||
bool want_zero, int64_t offset,
|
||||
int64_t bytes, int64_t *pnum,
|
||||
int64_t *map,
|
||||
BlockDriverState **file)
|
||||
{
|
||||
BdrvCoBlockStatusData data = {
|
||||
.bs = bs,
|
||||
.base = base,
|
||||
.want_zero = want_zero,
|
||||
.offset = offset,
|
||||
.bytes = bytes,
|
||||
.pnum = pnum,
|
||||
.map = map,
|
||||
.file = file,
|
||||
};
|
||||
|
||||
return bdrv_run_co(bs, bdrv_block_status_above_co_entry, &data);
|
||||
}
|
||||
|
||||
int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
|
||||
int64_t offset, int64_t bytes, int64_t *pnum,
|
||||
int64_t *map, BlockDriverState **file)
|
||||
@ -2624,13 +2505,6 @@ int bdrv_is_allocated_above(BlockDriverState *top,
|
||||
return 0;
|
||||
}
|
||||
|
||||
typedef struct BdrvVmstateCo {
|
||||
BlockDriverState *bs;
|
||||
QEMUIOVector *qiov;
|
||||
int64_t pos;
|
||||
bool is_read;
|
||||
} BdrvVmstateCo;
|
||||
|
||||
int coroutine_fn
|
||||
bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
|
||||
bool is_read)
|
||||
@ -2657,26 +2531,6 @@ bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int coroutine_fn bdrv_co_rw_vmstate_entry(void *opaque)
|
||||
{
|
||||
BdrvVmstateCo *co = opaque;
|
||||
|
||||
return bdrv_co_rw_vmstate(co->bs, co->qiov, co->pos, co->is_read);
|
||||
}
|
||||
|
||||
int bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
|
||||
bool is_read)
|
||||
{
|
||||
BdrvVmstateCo data = {
|
||||
.bs = bs,
|
||||
.qiov = qiov,
|
||||
.pos = pos,
|
||||
.is_read = is_read,
|
||||
};
|
||||
|
||||
return bdrv_run_co(bs, bdrv_co_rw_vmstate_entry, &data);
|
||||
}
|
||||
|
||||
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
|
||||
int64_t pos, int size)
|
||||
{
|
||||
@ -2752,11 +2606,6 @@ void bdrv_aio_cancel_async(BlockAIOCB *acb)
|
||||
/**************************************************************/
|
||||
/* Coroutine block device emulation */
|
||||
|
||||
static int coroutine_fn bdrv_flush_co_entry(void *opaque)
|
||||
{
|
||||
return bdrv_co_flush(opaque);
|
||||
}
|
||||
|
||||
int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
|
||||
{
|
||||
BdrvChild *primary_child = bdrv_primary_child(bs);
|
||||
@ -2880,24 +2729,6 @@ early_exit:
|
||||
return ret;
|
||||
}
|
||||
|
||||
int bdrv_flush(BlockDriverState *bs)
|
||||
{
|
||||
return bdrv_run_co(bs, bdrv_flush_co_entry, bs);
|
||||
}
|
||||
|
||||
typedef struct DiscardCo {
|
||||
BdrvChild *child;
|
||||
int64_t offset;
|
||||
int64_t bytes;
|
||||
} DiscardCo;
|
||||
|
||||
static int coroutine_fn bdrv_pdiscard_co_entry(void *opaque)
|
||||
{
|
||||
DiscardCo *rwco = opaque;
|
||||
|
||||
return bdrv_co_pdiscard(rwco->child, rwco->offset, rwco->bytes);
|
||||
}
|
||||
|
||||
int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset,
|
||||
int64_t bytes)
|
||||
{
|
||||
@ -3012,17 +2843,6 @@ out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes)
|
||||
{
|
||||
DiscardCo rwco = {
|
||||
.child = child,
|
||||
.offset = offset,
|
||||
.bytes = bytes,
|
||||
};
|
||||
|
||||
return bdrv_run_co(child->bs, bdrv_pdiscard_co_entry, &rwco);
|
||||
}
|
||||
|
||||
int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf)
|
||||
{
|
||||
BlockDriver *drv = bs->drv;
|
||||
@ -3424,35 +3244,3 @@ out:
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
typedef struct TruncateCo {
|
||||
BdrvChild *child;
|
||||
int64_t offset;
|
||||
bool exact;
|
||||
PreallocMode prealloc;
|
||||
BdrvRequestFlags flags;
|
||||
Error **errp;
|
||||
} TruncateCo;
|
||||
|
||||
static int coroutine_fn bdrv_truncate_co_entry(void *opaque)
|
||||
{
|
||||
TruncateCo *tco = opaque;
|
||||
|
||||
return bdrv_co_truncate(tco->child, tco->offset, tco->exact,
|
||||
tco->prealloc, tco->flags, tco->errp);
|
||||
}
|
||||
|
||||
int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
|
||||
PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
|
||||
{
|
||||
TruncateCo tco = {
|
||||
.child = child,
|
||||
.offset = offset,
|
||||
.exact = exact,
|
||||
.prealloc = prealloc,
|
||||
.flags = flags,
|
||||
.errp = errp,
|
||||
};
|
||||
|
||||
return bdrv_run_co(child->bs, bdrv_truncate_co_entry, &tco);
|
||||
}
|
||||
|
||||
@ -403,8 +403,9 @@ void bdrv_refresh_filename(BlockDriverState *bs);
|
||||
int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
|
||||
PreallocMode prealloc, BdrvRequestFlags flags,
|
||||
Error **errp);
|
||||
int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
|
||||
PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
|
||||
int generated_co_wrapper
|
||||
bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
|
||||
PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
|
||||
|
||||
int64_t bdrv_nb_sectors(BlockDriverState *bs);
|
||||
int64_t bdrv_getlength(BlockDriverState *bs);
|
||||
@ -446,7 +447,8 @@ typedef enum {
|
||||
BDRV_FIX_ERRORS = 2,
|
||||
} BdrvCheckMode;
|
||||
|
||||
int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
|
||||
int generated_co_wrapper bdrv_check(BlockDriverState *bs, BdrvCheckResult *res,
|
||||
BdrvCheckMode fix);
|
||||
|
||||
/* The units of offset and total_work_size may be chosen arbitrarily by the
|
||||
* block driver; total_work_size may change during the course of the amendment
|
||||
@ -470,12 +472,13 @@ void bdrv_aio_cancel_async(BlockAIOCB *acb);
|
||||
int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
|
||||
|
||||
/* Invalidate any cached metadata used by image formats */
|
||||
int bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);
|
||||
int generated_co_wrapper bdrv_invalidate_cache(BlockDriverState *bs,
|
||||
Error **errp);
|
||||
void bdrv_invalidate_cache_all(Error **errp);
|
||||
int bdrv_inactivate_all(void);
|
||||
|
||||
/* Ensure contents are flushed to disk. */
|
||||
int bdrv_flush(BlockDriverState *bs);
|
||||
int generated_co_wrapper bdrv_flush(BlockDriverState *bs);
|
||||
int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
|
||||
int bdrv_flush_all(void);
|
||||
void bdrv_close_all(void);
|
||||
@ -490,7 +493,8 @@ void bdrv_drain_all(void);
|
||||
AIO_WAIT_WHILE(bdrv_get_aio_context(bs_), \
|
||||
cond); })
|
||||
|
||||
int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
|
||||
int generated_co_wrapper bdrv_pdiscard(BdrvChild *child, int64_t offset,
|
||||
int64_t bytes);
|
||||
int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
|
||||
int bdrv_has_zero_init_1(BlockDriverState *bs);
|
||||
int bdrv_has_zero_init(BlockDriverState *bs);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user