coroutines: generate wrapper code
Subsystems (2)
v6 cover coroutines: generate wrapper code
Hi all!
The aim of the series is to reduce code-duplication and writing parameters structure-packing by hand around coroutine function wrappers.
Benefits:
- no code duplication
- less indirection
v6: rebase on master (mostly because of introducing bdrv_run_co()) 01: grammar/wording in commit messageq
02: rebase on master, drop r-b
03: contextual changes, keep r-b
04: use stdout=subprocess.PIPE instead of capture_output=True
to support older python
05: rebase on master, drop r-b
For convenience I attach generated block/block-gen.c file below.
Vladimir Sementsov-Ogievskiy (7):
block: return error-code from bdrv_invalidate_cache block/io: refactor coroutine wrappers
block: declare some coroutine functions in block/coroutines.h
scripts: add coroutine-wrapper.py
block: generate coroutine-wrapper code
block: drop bdrv_prwv
block/io: refactor save/load vmstate
Makefile | 8 + block/block-gen.h | 55 +++++ block/coroutines.h | 66 ++++++ include/block/block.h | 25 +- include/block/generated-co-wrapper.h | 35 +++ block.c | 97 ++------ block/io.c | 336 ++++----------------------- tests/test-bdrv-drain.c | 2 +- block/Makefile.objs | 1 + scripts/coroutine-wrapper.py | 174 ++++++++++++++ 10 files changed, 418 insertions(+), 381 deletions(-) create mode 100644 block/block-gen.h create mode 100644 block/coroutines.h create mode 100644 include/block/generated-co-wrapper.h create mode 100755 scripts/coroutine-wrapper.py
============ generated block/block-gen.c ===============
/*
* File is generated by scripts/coroutine-wrapper.py
*
* Copyright (c) 2020 Virtuozzo International GmbH.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include "block/coroutines.h"
#include "block/block-gen.h"
/*
* Wrappers for bdrv_co_truncate
*/
typedef struct BdrvCoTruncate {
BdrvPollCo poll_state;
BdrvChild *child;
int64_t offset;
bool exact;
PreallocMode prealloc;
BdrvRequestFlags flags;
Error **errp;
} BdrvCoTruncate;static void coroutine_fn bdrv_co_truncate_entry(void *opaque)
{
BdrvCoTruncate *s = opaque;
s->poll_state.ret = bdrv_co_truncate(s->child, s->offset, s->exact,
s->prealloc, s->flags, s->errp);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
{
if (qemu_in_coroutine()) {
return bdrv_co_truncate(child, offset, exact, prealloc, flags, errp);
} else {
BdrvCoTruncate s = {
.poll_state.bs = child->bs,
.poll_state.in_progress = true,
.child = child,
.offset = offset,
.exact = exact,
.prealloc = prealloc,
.flags = flags,
.errp = errp,
};
s.poll_state.co = qemu_coroutine_create(bdrv_co_truncate_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_check
*/
typedef struct BdrvCoCheck {
BdrvPollCo poll_state;
BlockDriverState *bs;
BdrvCheckResult *res;
BdrvCheckMode fix;
} BdrvCoCheck;static void coroutine_fn bdrv_co_check_entry(void *opaque)
{
BdrvCoCheck *s = opaque;
s->poll_state.ret = bdrv_co_check(s->bs, s->res, s->fix);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
{
if (qemu_in_coroutine()) {
return bdrv_co_check(bs, res, fix);
} else {
BdrvCoCheck s = {
.poll_state.bs = bs,
.poll_state.in_progress = true,
.bs = bs,
.res = res,
.fix = fix,
};
s.poll_state.co = qemu_coroutine_create(bdrv_co_check_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_invalidate_cache
*/
typedef struct BdrvCoInvalidateCache {
BdrvPollCo poll_state;
BlockDriverState *bs;
Error **errp;
} BdrvCoInvalidateCache;static void coroutine_fn bdrv_co_invalidate_cache_entry(void *opaque)
{
BdrvCoInvalidateCache *s = opaque;
s->poll_state.ret = bdrv_co_invalidate_cache(s->bs, s->errp);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
{
if (qemu_in_coroutine()) {
return bdrv_co_invalidate_cache(bs, errp);
} else {
BdrvCoInvalidateCache s = {
.poll_state.bs = bs,
.poll_state.in_progress = true,
.bs = bs,
.errp = errp,
};
s.poll_state.co =
qemu_coroutine_create(bdrv_co_invalidate_cache_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_flush
*/
typedef struct BdrvCoFlush {
BdrvPollCo poll_state;
BlockDriverState *bs;
} BdrvCoFlush;static void coroutine_fn bdrv_co_flush_entry(void *opaque)
{
BdrvCoFlush *s = opaque;
s->poll_state.ret = bdrv_co_flush(s->bs);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_flush(BlockDriverState *bs)
{
if (qemu_in_coroutine()) {
return bdrv_co_flush(bs);
} else {
BdrvCoFlush s = {
.poll_state.bs = bs,
.poll_state.in_progress = true,
.bs = bs,
};
s.poll_state.co = qemu_coroutine_create(bdrv_co_flush_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_pdiscard
*/
typedef struct BdrvCoPdiscard {
BdrvPollCo poll_state;
BdrvChild *child;
int64_t offset;
int64_t bytes;
} BdrvCoPdiscard;static void coroutine_fn bdrv_co_pdiscard_entry(void *opaque)
{
BdrvCoPdiscard *s = opaque;
s->poll_state.ret = bdrv_co_pdiscard(s->child, s->offset, s->bytes);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes)
{
if (qemu_in_coroutine()) {
return bdrv_co_pdiscard(child, offset, bytes);
} else {
BdrvCoPdiscard s = {
.poll_state.bs = child->bs,
.poll_state.in_progress = true,
.child = child,
.offset = offset,
.bytes = bytes,
};
s.poll_state.co = qemu_coroutine_create(bdrv_co_pdiscard_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_readv_vmstate
*/
typedef struct BdrvCoReadvVmstate {
BdrvPollCo poll_state;
BlockDriverState *bs;
QEMUIOVector *qiov;
int64_t pos;
} BdrvCoReadvVmstate;static void coroutine_fn bdrv_co_readv_vmstate_entry(void *opaque)
{
BdrvCoReadvVmstate *s = opaque;
s->poll_state.ret = bdrv_co_readv_vmstate(s->bs, s->qiov, s->pos);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
{
if (qemu_in_coroutine()) {
return bdrv_co_readv_vmstate(bs, qiov, pos);
} else {
BdrvCoReadvVmstate s = {
.poll_state.bs = bs,
.poll_state.in_progress = true,
.bs = bs,
.qiov = qiov,
.pos = pos,
};
s.poll_state.co =
qemu_coroutine_create(bdrv_co_readv_vmstate_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_writev_vmstate
*/
typedef struct BdrvCoWritevVmstate {
BdrvPollCo poll_state;
BlockDriverState *bs;
QEMUIOVector *qiov;
int64_t pos;
} BdrvCoWritevVmstate;static void coroutine_fn bdrv_co_writev_vmstate_entry(void *opaque)
{
BdrvCoWritevVmstate *s = opaque;
s->poll_state.ret = bdrv_co_writev_vmstate(s->bs, s->qiov, s->pos);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
{
if (qemu_in_coroutine()) {
return bdrv_co_writev_vmstate(bs, qiov, pos);
} else {
BdrvCoWritevVmstate s = {
.poll_state.bs = bs,
.poll_state.in_progress = true,
.bs = bs,
.qiov = qiov,
.pos = pos,
};
s.poll_state.co =
qemu_coroutine_create(bdrv_co_writev_vmstate_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_preadv
*/
typedef struct BdrvCoPreadv {
BdrvPollCo poll_state;
BdrvChild *child;
int64_t offset;
unsigned int bytes;
QEMUIOVector *qiov;
BdrvRequestFlags flags;
} BdrvCoPreadv;static void coroutine_fn bdrv_co_preadv_entry(void *opaque)
{
BdrvCoPreadv *s = opaque;
s->poll_state.ret =
bdrv_co_preadv(s->child, s->offset, s->bytes, s->qiov, s->flags);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_preadv(BdrvChild *child, int64_t offset, unsigned int bytes,
QEMUIOVector *qiov, BdrvRequestFlags flags)
{
if (qemu_in_coroutine()) {
return bdrv_co_preadv(child, offset, bytes, qiov, flags);
} else {
BdrvCoPreadv s = {
.poll_state.bs = child->bs,
.poll_state.in_progress = true,
.child = child,
.offset = offset,
.bytes = bytes,
.qiov = qiov,
.flags = flags,
};
s.poll_state.co = qemu_coroutine_create(bdrv_co_preadv_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_pwritev
*/
typedef struct BdrvCoPwritev {
BdrvPollCo poll_state;
BdrvChild *child;
int64_t offset;
unsigned int bytes;
QEMUIOVector *qiov;
BdrvRequestFlags flags;
} BdrvCoPwritev;static void coroutine_fn bdrv_co_pwritev_entry(void *opaque)
{
BdrvCoPwritev *s = opaque;
s->poll_state.ret =
bdrv_co_pwritev(s->child, s->offset, s->bytes, s->qiov, s->flags);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}int bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,
QEMUIOVector *qiov, BdrvRequestFlags flags)
{
if (qemu_in_coroutine()) {
return bdrv_co_pwritev(child, offset, bytes, qiov, flags);
} else {
BdrvCoPwritev s = {
.poll_state.bs = child->bs,
.poll_state.in_progress = true,
.child = child,
.offset = offset,
.bytes = bytes,
.qiov = qiov,
.flags = flags,
};
s.poll_state.co = qemu_coroutine_create(bdrv_co_pwritev_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}/*
* Wrappers for bdrv_co_common_block_status_above
*/
typedef struct BdrvCoCommonBlockStatusAbove {
BdrvPollCo poll_state;
BlockDriverState *bs;
BlockDriverState *base;
bool want_zero;
int64_t offset;
int64_t bytes;
int64_t *pnum;
int64_t *map;
BlockDriverState **file;
} BdrvCoCommonBlockStatusAbove;static void coroutine_fn bdrv_co_common_block_status_above_entry(void *opaque)
{
BdrvCoCommonBlockStatusAbove *s = opaque;
s->poll_state.ret = bdrv_co_common_block_status_above(
s->bs, s->base, s->want_zero, s->offset, s->bytes, s->pnum, s->map,
s->file);
s->poll_state.in_progress = false;
bdrv_poll_co__on_exit();
}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)
{
if (qemu_in_coroutine()) {
return bdrv_co_common_block_status_above(bs, base, want_zero, offset,
bytes, pnum, map, file);
} else {
BdrvCoCommonBlockStatusAbove s = {
.poll_state.bs = bs,
.poll_state.in_progress = true,
.bs = bs,
.base = base,
.want_zero = want_zero,
.offset = offset,
.bytes = bytes,
.pnum = pnum,
.map = map,
.file = file,
};
s.poll_state.co =
qemu_coroutine_create(bdrv_co_common_block_status_above_entry, &s);
return bdrv_poll_co(&s.poll_state);
}
}=============================================================
Signature · 1 line
2.21.0
PATCH v6 1/7 block: return error-code from bdrv_invalidate_cache
This is the only coroutine wrapper from block.c and block/io.c which doesn't return a value, so let's convert it to the common behavior, to simplify moving to generated coroutine wrappers in a further commit.
Also, bdrv_invalidate_cache is a void function, returning error only through **errp parameter, which is considered to be bad practice, as it forces callers to define and propagate local_err variable, so conversion is good anyway.
This patch leaves the conversion of .bdrv_co_invalidate_cache() driver callbacks and bdrv_invalidate_cache_all() for another day.
--- include/block/block.h | 2 +- block.c | 32 ++++++++++++++++++-------------- 2 files changed, 19 insertions(+), 15 deletions(-)
include/block/block.h +1 -1
@@ -464,7 +464,7 @@ 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 */ -void bdrv_invalidate_cache (BlockDriverState *bs,Error **errp); +int bdrv_invalidate_cache (BlockDriverState *bs,Error **errp);void bdrv_invalidate_cache_all (Error **errp);int bdrv_inactivate_all (void );
block.c +18 -14
@@ -5643,8 +5643,8 @@ void bdrv_init_with_whitelist(void)bdrv_init (); } -static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, -Error **errp) +static int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, +Error **errp) {BdrvChild *child, *parent;uint64_t perm, shared_perm;
@@ -5653,14 +5653,14 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,BdrvDirtyBitmap *bm;if (!bs->drv) { -return ; +return -ENOMEDIUM ; } QLIST_FOREACH(child, &bs->children, next) {bdrv_co_invalidate_cache (child->bs, &local_err);if (local_err) {error_propagate (errp, local_err); -return ; +return -EINVAL ; } }
@@ -5684,7 +5684,7 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,if (ret <0 ) { bs->open_flags |=BDRV_O_INACTIVE ;error_propagate (errp, local_err); -return ; +return ret; }bdrv_set_perm (bs, perm, shared_perm);
@@ -5693,7 +5693,7 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,if (local_err) { bs->open_flags |=BDRV_O_INACTIVE ;error_propagate (errp, local_err); -return ; +return -EINVAL ; } }
@@ -5705,7 +5705,7 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,if (ret <0 ) { bs->open_flags |=BDRV_O_INACTIVE ;error_setg_errno (errp, -ret,"Could not refresh total sector count" ); -return ; +return ret; } }
@@ -5715,27 +5715,30 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,if (local_err) { bs->open_flags |=BDRV_O_INACTIVE ;error_propagate (errp, local_err); -return ; +return -EINVAL ; } } } + +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; -bdrv_co_invalidate_cache (ico->bs, ico->errp); + ico->ret =bdrv_co_invalidate_cache (ico->bs, ico->errp); ico->done = true;aio_wait_kick (); } -void bdrv_invalidate_cache (BlockDriverState *bs,Error **errp) +int bdrv_invalidate_cache (BlockDriverState *bs,Error **errp) {Coroutine *co;InvalidateCacheCo ico = {
@@ -5752,22 +5755,23 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)bdrv_coroutine_enter (bs, co);BDRV_POLL_WHILE (bs, !ico.done); } + +return ico.ret; }void bdrv_invalidate_cache_all (Error **errp) {BlockDriverState *bs; -Error *local_err =NULL ;BdrvNextIterator it;for (bs =bdrv_first (&it); bs; bs =bdrv_next (&it)) {AioContext *aio_context =bdrv_get_aio_context (bs); +int ret;aio_context_acquire (aio_context); -bdrv_invalidate_cache (bs, &local_err); + ret =bdrv_invalidate_cache (bs, errp);aio_context_release (aio_context); -if (local_err) { -error_propagate (errp, local_err); +if (ret <0 ) {bdrv_next_cleanup (&it);return ; }
Signature · 1 line
2.21.0
PATCH v6 2/7 block/io: refactor coroutine wrappers
In reply to Vladimir Sementsov-OgievskiyMost of our coroutine wrappers already follow this convention:
We have 'coroutine_fn bdrv_co_<something>(<normal argument list>)' as the core function, and a wrapper 'bdrv_<something>(<same argument list>)' which does parameters packing and call bdrv_run_co().
The only outsiders are the bdrv_prwv_co and bdrv_common_block_status_above wrappers. Let's refactor them to behave as the others, it simplifies further conversion of coroutine wrappers.
This patch adds indirection layer, but it will be compensated by further commit, which will drop bdrv_co_prwv together with is_write logic, to keep read and write patch separate.
--- block/io.c | 60 +++++++++++++++++++++++++++++------------------------- 1 file changed, 32 insertions(+), 28 deletions(-)
block/io.c +32 -28
@@ -933,27 +933,31 @@ typedef struct RwCo {BdrvRequestFlags flags; } RwCo; +static int coroutine_fn bdrv_co_prwv(BdrvChild *child, int64_t offset, +QEMUIOVector *qiov,bool is_write, +BdrvRequestFlags flags) +{ +if (is_write) { +return bdrv_co_pwritev (child, offset, qiov->size, qiov, flags); + }else { +return bdrv_co_preadv (child, offset, qiov->size, qiov, flags); + } +} + static int coroutine_fn bdrv_rw_co_entry(void *opaque) {RwCo *rwco = opaque; -if (!rwco->is_write) { -return bdrv_co_preadv (rwco->child, rwco->offset, - rwco->qiov->size, rwco->qiov, - rwco->flags); - }else { -return bdrv_co_pwritev (rwco->child, rwco->offset, - rwco->qiov->size, rwco->qiov, - rwco->flags); - } +return bdrv_co_prwv (rwco->child, rwco->offset, rwco->qiov, + rwco->is_write, rwco->flags); }/* * Process a vectored synchronous request using coroutines */ -static int bdrv_prwv_co (BdrvChild *child,int64_t offset, -QEMUIOVector *qiov,bool is_write, -BdrvRequestFlags flags) +static int bdrv_prwv (BdrvChild *child,int64_t offset, +QEMUIOVector *qiov,bool is_write, +BdrvRequestFlags flags) {RwCo rwco = { .child = child,
@@ -971,8 +975,7 @@ int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset, {QEMUIOVector qiov =QEMU_IOVEC_INIT_BUF (qiov,NULL , bytes); -return bdrv_prwv_co (child, offset, &qiov, true, -BDRV_REQ_ZERO_WRITE | flags); +return bdrv_prwv (child, offset, &qiov, true,BDRV_REQ_ZERO_WRITE | flags); }/*
@@ -1021,7 +1024,7 @@ int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov) {int ret; - ret =bdrv_prwv_co (child, offset, qiov, false,0 ); + ret =bdrv_prwv (child, offset, qiov, false,0 );if (ret <0 ) {return ret; }
@@ -1045,7 +1048,7 @@ int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov) {int ret; - ret =bdrv_prwv_co (child, offset, qiov, true,0 ); + ret =bdrv_prwv (child, offset, qiov, true,0 );if (ret <0 ) {return ret; }
@@ -2463,14 +2466,15 @@ early_out:return ret; } -static int coroutine_fn bdrv_co_block_status_above(BlockDriverState *bs, -BlockDriverState *base, -bool want_zero, -int64_t offset, -int64_t bytes, -int64_t *pnum, -int64_t *map, -BlockDriverState **file) +static int coroutine_fn +bdrv_co_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) {BlockDriverState *p;int ret =0 ;
@@ -2508,10 +2512,10 @@ static int coroutine_fn bdrv_block_status_above_co_entry(void *opaque) {BdrvCoBlockStatusData *data = opaque; -return bdrv_co_block_status_above (data->bs, data->base, - data->want_zero, - data->offset, data->bytes, - data->pnum, data->map, data->file); +return bdrv_co_common_block_status_above (data->bs, data->base, + data->want_zero, + data->offset, data->bytes, + data->pnum, data->map, data->file); }/*
Signature · 1 line
2.21.0
Re: [PATCH v6 2/7] block/io: refactor coroutine wrappers
Quoted 6 lines · Vladimir Sementsov-Ogievskiy
Most of our coroutine wrappers already follow this convention:
We have '
coroutine_fnbdrv_co_<something>(<normal argument list>)' as the core function, and a wrapper 'bdrv_<something>(<same argument list>)' which does parameters packing and callbdrv_run_co().
Quoted 7 lines
The only outsiders are the
bdrv_prwv_coandbdrv_common_block_status_abovewrappers. Let's refactor them to behave as the others, it simplifies further conversion of coroutine wrappers.This patch adds indirection layer, but it will be compensated by further commit, which will drop
bdrv_co_prwvtogether withis_writelogic, to keep read and write patch separate.
s/patch/path/
Quoted 6 lines
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/io.c | 60 +++++++++++++++++++++++++++++------------------------- 1 file changed, 32 insertions(+), 28 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
PATCH v6 3/7 block: declare some coroutine functions in block/coroutines.h
In reply to Vladimir Sementsov-OgievskiyWe are going to keep coroutine-wrappers code (structure-packing parameters, BDRV_POLL wrapper functions) in separate auto-generated files. So, we'll need a header with declaration of original _co_ functions, for those which are static now. As well, we'll need declarations for wrapper functions. Do these declarations now, as a preparation step.
--- block/coroutines.h | 67 ++++++++++++++++++++++++++++++++++++++++++++++ block.c | 8 +++--- block/io.c | 34 +++++++++++------------ 3 files changed, 88 insertions(+), 21 deletions(-) create mode 100644 block/coroutines.h
block/coroutines.h new file +67 -0
@@ -0,0 +1,67 @@ +/* +* Block layer I/O functions +* +* Copyright (c) 2003 Fabrice Bellard +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +* THE SOFTWARE. +*/ + +#ifndef BLOCK_COROUTINES_INT_H +#define BLOCK_COROUTINES_INT_H + +#include "block/block_int.h" + +int coroutine_fn bdrv_co_check(BlockDriverState *bs, +BdrvCheckResult *res,BdrvCheckMode fix); +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 +bdrv_prwv (BdrvChild *child,int64_t offset,QEMUIOVector *qiov, +bool is_write,BdrvRequestFlags flags); + +int coroutine_fn +bdrv_co_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); +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); + +int coroutine_fn +bdrv_co_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos, +bool is_read); +int +bdrv_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos, +bool is_read); + +#endif /* BLOCK_COROUTINES_INT_H */
block.c +4 -4
@@ -48,6 +48,7 @@#include "qemu/timer.h" #include "qemu/cutils.h" #include "qemu/id.h" +#include "block/coroutines.h" #ifdef CONFIG_BSD #include <sys/ioctl.h>
@@ -4625,8 +4626,8 @@ static void bdrv_delete(BlockDriverState *bs)* free of errors) or -errno when an internal error occurred. The results of the * check are stored in res. */ -static int coroutine_fn bdrv_co_check(BlockDriverState *bs, -BdrvCheckResult *res,BdrvCheckMode fix) +int coroutine_fn bdrv_co_check(BlockDriverState *bs, +BdrvCheckResult *res,BdrvCheckMode fix) {if (bs->drv ==NULL ) {return -ENOMEDIUM ;
@@ -5643,8 +5644,7 @@ void bdrv_init_with_whitelist(void)bdrv_init (); } -static int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, -Error **errp) +int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) {BdrvChild *child, *parent;uint64_t perm, shared_perm;
block/io.c +17 -17
@@ -29,6 +29,7 @@#include "block/blockjob.h" #include "block/blockjob_int.h" #include "block/block_int.h" +#include "block/coroutines.h" #include "qemu/cutils.h" #include "qapi/error.h" #include "qemu/error-report.h"
@@ -933,9 +934,9 @@ typedef struct RwCo {BdrvRequestFlags flags; } RwCo; -static int coroutine_fn bdrv_co_prwv(BdrvChild *child, int64_t offset, -QEMUIOVector *qiov,bool is_write, -BdrvRequestFlags flags) +int coroutine_fn bdrv_co_prwv(BdrvChild *child, int64_t offset, +QEMUIOVector *qiov,bool is_write, +BdrvRequestFlags flags) {if (is_write) {return bdrv_co_pwritev (child, offset, qiov->size, qiov, flags);
@@ -955,9 +956,9 @@ static int coroutine_fn bdrv_rw_co_entry(void *opaque)/* * Process a vectored synchronous request using coroutines */ -static int bdrv_prwv (BdrvChild *child,int64_t offset, -QEMUIOVector *qiov,bool is_write, -BdrvRequestFlags flags) +int bdrv_prwv (BdrvChild *child,int64_t offset, +QEMUIOVector *qiov,bool is_write, +BdrvRequestFlags flags) {RwCo rwco = { .child = child,
@@ -2466,7 +2467,7 @@ early_out:return ret; } -static int coroutine_fn +int coroutine_fn bdrv_co_common_block_status_above(BlockDriverState *bs, BlockDriverState *base, bool want_zero,
@@ -2523,12 +2524,12 @@ static int coroutine_fn bdrv_block_status_above_co_entry(void *opaque)* * See bdrv_co_block_status_above() for details. */ -static 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) +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,
@@ -2644,7 +2645,7 @@ typedef struct BdrvVmstateCo {bool is_read; } BdrvVmstateCo; -static int coroutine_fn +int coroutine_fnbdrv_co_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos,bool is_read) {
@@ -2676,9 +2677,8 @@ static int coroutine_fn bdrv_co_rw_vmstate_entry(void *opaque)return bdrv_co_rw_vmstate (co->bs, co->qiov, co->pos, co->is_read); } -static inline int -bdrv_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos, -bool is_read) +int bdrv_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos, +bool is_read) {BdrvVmstateCo data = { .bs = bs,
Signature · 1 line
2.21.0
PATCH v6 4/7 scripts: add coroutine-wrapper.py
In reply to Vladimir Sementsov-OgievskiyWe have a very frequent pattern of creating coroutine from function with several arguments:
- create structure to pack parameters
- create _entry function to call original function taking parameters from struct
- do different magic to handle completion: set ret to NOT_DONE or EINPROGRESS, use separate bool for void functions
- fill the struct and create coroutine from _entry function and this struct as a parameter
- do coroutine enter and BDRV_POLL_WHILE loop
Let's reduce code duplication by generating coroutine wrappers.
This patch adds scripts/coroutine-wrapper.py together with some friends, which will generate functions with declared prototypes marked by 'generated_co_wrapper' specifier.
The usage of new code generation is as follows:
1. define somewhere
int coroutine_fn bdrv_co_NAME(...) {...}
function
2. declare in some header file
int generated_co_wrapper bdrv_NAME(...);
function with same list of parameters. (you'll need to include "block/generated-co-wrapper.h" to get the specifier)
3. both declarations should be available through block/coroutines.h header.
4. add header with generated_co_wrapper declaration into COROUTINE_HEADERS list in Makefile
Still, no function is now marked, this work is for the following commit.
--- Makefile | 8 ++ block/block-gen.h | 55 +++++++++ include/block/generated-co-wrapper.h | 35 ++++++ block/Makefile.objs | 1 + scripts/coroutine-wrapper.py | 174 +++++++++++++++++++++++++++ 5 files changed, 273 insertions(+) create mode 100644 block/block-gen.h create mode 100644 include/block/generated-co-wrapper.h create mode 100755 scripts/coroutine-wrapper.py
Makefile +8 -0
@@ -175,6 +175,14 @@ generated-files-y += $(TRACE_SOURCES) generated-files-y += $(BUILD_DIR)/trace-events-all generated-files-y += .git-submodule-status +generated-files-y += block/block-gen.c + +COROUTINE_HEADERS = include/block/block.h block/coroutines.h +block/block-gen.c: $(COROUTINE_HEADERS) scripts/coroutine-wrapper.py + $(call quiet-command, \ + cat $(addprefix $(SRC_PATH)/,$(COROUTINE_HEADERS)) | \ + $(SRC_PATH)/scripts/coroutine-wrapper.py > $@,"GEN","$(TARGET_DIR)$@") + trace-group-name = $(shell dirname $1 | sed -e 's/[^a-zA-Z0-9]/_/g') tracetool-y = $(SRC_PATH)/scripts/tracetool.py
block/block-gen.h new file +55 -0
55 lines not on this page · raw message
include/block/generated-co-wrapper.h new file +35 -0
@@ -0,0 +1,35 @@ +/* +* Block layer I/O functions +* +* Copyright (c) 2020 Virtuozzo International GmbH +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +* THE SOFTWARE. +*/ + +#ifndef BLOCK_GENERATED_CO_WRAPPER_H +#define BLOCK_GENERATED_CO_WRAPPER_H + +/* +* generated_co_wrapper +* Function specifier, which does nothing but marking functions to be +* generated by scripts/coroutine-wrapper.py +*/ +#define generated_co_wrapper + +#endif /* BLOCK_GENERATED_CO_WRAPPER_H */
block/Makefile.objs +1 -0
@@ -45,6 +45,7 @@ block-obj-y += crypto.o block-obj-y += aio_task.o block-obj-y += backup-top.o block-obj-y += filter-compress.o +block-obj-y += block-gen.o common-obj-y += monitor/ block-obj-y += stream.o
scripts/coroutine-wrapper.py new file +174 -0
174 lines not on this page · raw message
Signature · 1 line
2.21.0
Re: [PATCH v6 4/7] scripts: add coroutine-wrapper.py
Quoted 8 lines · Vladimir Sementsov-Ogievskiy
We have a very frequent pattern of creating coroutine from function with several arguments:
- create structure to pack parameters
- create_entryfunction to call original function taking parameters from struct
- do different magic to handle completion: set ret toNOT_DONEor EINPROGRESS, use separate bool for void functions
Stale comment, now that you got rid of void functions earlier in the series.
Quoted 42 lines
- fill the struct and create coroutine from
_entryfunction and this struct as a parameter
- do coroutine enter andBDRV_POLL_WHILEloopLet's reduce code duplication by generating coroutine wrappers.
This patch adds
scripts/coroutine-wrapper.pytogether with some friends, which will generate functions with declared prototypes marked by 'generated_co_wrapper' specifier.The usage of new code generation is as follows:
1. define somewhere
int
coroutine_fnbdrv_co_NAME(...){...}function
2. declare in some header file
int
generated_co_wrapperbdrv_NAME(...);function with same list of parameters. (you'll need to include "
block/generated-co-wrapper.h" to get the specifier)3. both declarations should be available through
block/coroutines.hheader.4. add header with
generated_co_wrapperdeclaration intoCOROUTINE_HEADERSlist inMakefileStill, no function is now marked, this work is for the following commit.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- Makefile | 8 ++ block/block-gen.h | 55 +++++++++ include/block/generated-co-wrapper.h | 35 ++++++ block/Makefile.objs | 1 + scripts/coroutine-wrapper.py | 174 +++++++++++++++++++++++++++ 5 files changed, 273 insertions(+)
Quoted 3 lines
create mode 100644
block/block-gen.h
create mode 100644include/block/generated-co-wrapper.hcreate mode 100755scripts/coroutine-wrapper.py
My python review is weak, but here goes.
Review
Quoted 10 lines
+++
b/block/block-gen.h(quoted diff) +8
-0+ +#include "block/block_int.h" + +/* This function is called at the end of generated coroutine entries. */ +static inline void bdrv_poll_co__on_exit(void) +{ + aio_wait_kick(); +}
I still think it's worth inlining aio_wait_kick() into the generated code, instead of this one-line wrapper function. Patch below.
Quoted 25 lines
(quoted diff) +20
-0+ +/* Base structure for argument packing structures */ +typedef struct BdrvPollCo { + BlockDriverState *bs; + bool in_progress; + int ret; + Coroutine *co; /* Keep pointer here for debugging */ +} BdrvPollCo; + +static inline int bdrv_poll_co(BdrvPollCo *s) +{ + assert(!qemu_in_coroutine()); + + bdrv_coroutine_enter(s->bs, s->co); + BDRV_POLL_WHILE(s->bs, s->in_progress); + + return s->ret; +} + +#endif /* BLOCK_BLOCK_GEN_H */include/block/generated-co-wrapper.h new file +0
-0
include/block/generated-co-wrapper.h
Quoted 10 lines
include/block/generated-co-wrapper.h new file +9
-0+#ifndef BLOCK_GENERATED_CO_WRAPPER_H +#define BLOCK_GENERATED_CO_WRAPPER_H + +/* +* generated_co_wrapper +* Function specifier, which does nothing but marking functions to be +* generated by scripts/coroutine-wrapper.py +*/ +#define generated_co_wrapper
Do we need a standalone header just for this definition, or could we stick it in include/block/block.h? Also in my patch below.
Quoted 6 lines
scripts/coroutine-wrapper.py new file +0
-0
scripts/coroutine-wrapper.py
Quoted 10 lines
scripts/coroutine-wrapper.py new file +9
-0@@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Generate coroutine wrappers for block subsystem. +def prettify(code: str) -> str: + """Prettify code using clang-format if available""" + + try: + style = '{IndentWidth: 4, BraceWrapping: {AfterFunction: true}, ' \ + 'BreakBeforeBraces: Custom, SortIncludes: false, ' \ + 'MaxEmptyLinesToKeep: 2}'
It looks odd to pass in style as a string (requiring \-newline) rather than a dict (which would not), but I guess that's because...
Quoted 1 line
+ p = subprocess.run(['clang-format', f'-style={style}'], check=True,
...you have to stringify it anyway for the subprocess command line.
scripts/coroutine-wrapper.py
Quoted 4 lines
scripts/coroutine-wrapper.py new file +4
-0+class ParamDecl: + param_re = re.compile(r'(?P<decl>' + r'(?P<type>.*[ *])' + r'(?P<name>[a-z][a-z0-9_]*)'
I guess you're safe not including A-Z based on our coding style.
Quoted 19 lines
scripts/coroutine-wrapper.py new file +19
-0+ r')') + + def __init__(self, param_decl: str) -> None: + m = self.param_re.match(param_decl.strip()) + if m is None: + raise ValueError(f'Wrong parameter declaration: "{param_decl}"') + self.decl = m.group('decl') + self.type = m.group('type') + self.name = m.group('name') + + +class FuncDecl: + def __init__(self, return_type: str, name: str, args: str) -> None: + self.return_type = return_type.strip() + self.name = name.strip() + self.args = [ParamDecl(arg.strip()) for arg in args.split(',')] + + def gen_list(self, format: str) -> str: + return ', '.join(format.format_map(arg.__dict__) for arg in self.args)
scripts/coroutine-wrapper.py
Quoted 10 lines
scripts/coroutine-wrapper.py new file +10
-0+ + def gen_block(self, format: str) -> str: + return '\n'.join(format.format_map(arg.__dict__) for arg in self.args) + + +# Match wrappers declared with a generated_co_wrapper mark +func_decl_re = re.compile(r'^int\s*generated_co_wrapper\s*' + r'(?P<wrapper_name>[a-z][a-z0-9_]*)' + r'\((?P<args>[^)]*)\);$', re.MULTILINE) +
Makes sense (requires coroutines to return int, but you fixed that earlier in the series).
scripts/coroutine-wrapper.py
Quoted 9 lines
scripts/coroutine-wrapper.py new file +9
-0+ +def func_decl_iter(text: str) -> Iterator: + for m in func_decl_re.finditer(text): + yield FuncDecl(return_type='int', + name=m.group('wrapper_name'), + args=m.group('args')) + + +def snake_to_camel(func_name: str) -> str:
...
Nothing else jumped out at me, so:
Still, here's the promised diffs I'm thinking of:
for 4/7
From 8c089d488ed8d9778fd5ee1f18dbc3845e4349f2 Mon Sep 17 00:00:00 2001
From: Vladimir Sementsov-Ogievskiy <[email protected]>
Date: Tue, 9 Jun 2020 17:13:26 +0300
Subject: [PATCH] fixup? scripts: add coroutine-wrapper.py
Worth squashing in to the coroutine generator?
--- scripts/coroutine-wrapper.py | 5 ++-- block/block-gen.h | 6 ----- include/block/block.h | 7 ++++++ include/block/generated-co-wrapper.h | 35 ---------------------------- 4 files changed, 10 insertions(+), 43 deletions(-) delete mode 100644 include/block/generated-co-wrapper.h
scripts/coroutine-wrapper.py +3 -2
@@ -57,7 +57,8 @@ def gen_header(): #include "qemu/osdep.h" #include "block/coroutines.h" -#include "block/block-gen.h"\ +#include "block/block-gen.h" +#include "block/block_int.h"\ """
@@ -139,7 +140,7 @@ static void coroutine_fn {name}_entry(void *opaque) s->poll_state.ret = {name}({ func.gen_list('s->{name}') }); s->poll_state.in_progress = false; - bdrv_poll_co__on_exit(); + aio_wait_kick(); }} int {func.name}({ func.gen_list('{decl}') })
block/block-gen.h +0 -6
@@ -28,12 +28,6 @@#include "block/block_int.h" -/* This function is called at the end of generated coroutine entries. */ -static inline void bdrv_poll_co__on_exit (void ) -{ -aio_wait_kick (); -} -/* Base structure for argument packing structures */ typedef struct BdrvPollCo { BlockDriverState *bs;
include/block/block.h +7 -0
@@ -10,6 +10,13 @@#include "block/blockjob.h" #include "qemu/hbitmap.h" +/* +* generated_co_wrapper +* Function specifier, which does nothing but marking functions to be +* generated by scripts/coroutine-wrapper.py +*/ +#define generated_co_wrapper +/* block.c */ typedef struct BlockDriver BlockDriver ;typedef struct BdrvChild BdrvChild ;
include/block/generated-co-wrapper.h deleted +0 -35
@@ -1,35 +0,0 @@ -/* -* Block layer I/O functions -* -* Copyright (c) 2020 Virtuozzo International GmbH -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -*/ - -#ifndef BLOCK_GENERATED_CO_WRAPPER_H -#define BLOCK_GENERATED_CO_WRAPPER_H - -/* -* generated_co_wrapper -* Function specifier, which does nothing but marking functions to be -* generated by scripts/coroutine-wrapper.py -*/ -#define generated_co_wrapper - -#endif /* BLOCK_GENERATED_CO_WRAPPER_H */
Signature · 5 lines
2.27.0 for 5/7
block/coroutines.h +0 -1
@@ -26,7 +26,6 @@#define BLOCK_COROUTINES_INT_H #include "block/block_int.h" -#include "block/generated-co-wrapper.h" int coroutine_fn bdrv_co_check(BlockDriverState *bs,BdrvCheckResult *res,BdrvCheckMode fix);
include/block/block.h +0 -1
@@ -9,7 +9,6 @@#include "block/dirty-bitmap.h" #include "block/blockjob.h" #include "qemu/hbitmap.h" -#include "block/generated-co-wrapper.h" /* * generated_co_wrapper
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v6 4/7] scripts: add coroutine-wrapper.py
Quoted 297 lines · Eric Blake
Quoted 8 lines · Vladimir Sementsov-Ogievskiy
We have a very frequent pattern of creating coroutine from function with several arguments:
- create structure to pack parameters
- create_entryfunction to call original function taking parameters from struct
- do different magic to handle completion: set ret toNOT_DONEor EINPROGRESS, use separate bool for void functionsStale comment, now that you got rid of void functions earlier in the series.
Quoted 41 lines
- fill the struct and create coroutine from
_entryfunction and this struct as a parameter
- do coroutine enter andBDRV_POLL_WHILEloopLet's reduce code duplication by generating coroutine wrappers.
This patch adds
scripts/coroutine-wrapper.pytogether with some friends, which will generate functions with declared prototypes marked by 'generated_co_wrapper' specifier.The usage of new code generation is as follows:
1. define somewhere
int
coroutine_fnbdrv_co_NAME(...){...}function
2. declare in some header file
int
generated_co_wrapperbdrv_NAME(...);function with same list of parameters. (you'll need to include "
block/generated-co-wrapper.h" to get the specifier)3. both declarations should be available through
block/coroutines.hheader.4. add header with
generated_co_wrapperdeclaration intoCOROUTINE_HEADERSlist inMakefileStill, no function is now marked, this work is for the following commit.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
Makefile | 8 ++ block/block-gen.h | 55 +++++++++include/block/generated-co-wrapper.h| 35 ++++++ block/Makefile.objs | 1 + scripts/coroutine-wrapper.py | 174 +++++++++++++++++++++++++++Quoted 4 lines
5 files changed, 273 insertions(+)create mode 100644
block/block-gen.h
create mode 100644include/block/generated-co-wrapper.hcreate mode 100755scripts/coroutine-wrapper.pyMy python review is weak, but here goes.
Review
Quoted 10 lines
+++
b/block/block-gen.h(quoted diff) +8
-0+ +#include "block/block_int.h" + +/* This function is called at the end of generated coroutine entries. */ +static inline void bdrv_poll_co__on_exit(void) +{ + aio_wait_kick(); +}I still think it's worth inlining
aio_wait_kick()into the generated code, instead of this one-line wrapper function. Patch below.Quoted 25 lines
(quoted diff) +20
-0+ +/* Base structure for argument packing structures */ +typedef struct BdrvPollCo { + BlockDriverState *bs; + bool in_progress; + int ret; + Coroutine *co; /* Keep pointer here for debugging */ +} BdrvPollCo; + +static inline int bdrv_poll_co(BdrvPollCo *s) +{ + assert(!qemu_in_coroutine()); + + bdrv_coroutine_enter(s->bs, s->co); + BDRV_POLL_WHILE(s->bs, s->in_progress); + + return s->ret; +} + +#endif /* BLOCK_BLOCK_GEN_H */include/block/generated-co-wrapper.h new file +0
-0include/block/generated-co-wrapper.h
Quoted 10 lines
include/block/generated-co-wrapper.h new file +9
-0+#ifndef BLOCK_GENERATED_CO_WRAPPER_H +#define BLOCK_GENERATED_CO_WRAPPER_H + +/* +* generated_co_wrapper +* Function specifier, which does nothing but marking functions to be +* generated by scripts/coroutine-wrapper.py +*/ +#define generated_co_wrapperDo we need a standalone header just for this definition, or could we stick it in include/block/block.h? Also in my patch below.
Quoted 6 lines
scripts/coroutine-wrapper.py new file +0
-0scripts/coroutine-wrapper.py
Quoted 10 lines
scripts/coroutine-wrapper.py new file +9
-0@@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Generate coroutine wrappers for block subsystem. +def prettify(code: str) -> str: + """Prettify code using clang-format if available""" + + try: + style = '{IndentWidth: 4, BraceWrapping: {AfterFunction: true}, ' \ + 'BreakBeforeBraces: Custom, SortIncludes: false, ' \ + 'MaxEmptyLinesToKeep: 2}'It looks odd to pass in style as a string (requiring \-newline) rather than a dict (which would not), but I guess that's because...
Quoted 1 line
+ p = subprocess.run(['clang-format', f'-style={style}'], check=True,
...you have to stringify it anyway for the subprocess command line.
Quoted 4 lines
+class ParamDecl:
+param_re= re.compile(r'(?P<decl>'
+ r'(?P<type>.*[ *])' + r'(?P<name>[a-z][a-z0-9_]*)'I guess you're safe not including A-Z based on our coding style.
Quoted 19 lines
+ r')')
scripts/coroutine-wrapper.py new file +18
-0+ + def __init__(self, param_decl: str) -> None: + m = self.param_re.match(param_decl.strip()) + if m is None: + raise ValueError(f'Wrong parameter declaration: "{param_decl}"') + self.decl = m.group('decl') + self.type = m.group('type') + self.name = m.group('name') + + +class FuncDecl: + def __init__(self, return_type: str, name: str, args: str) -> None: + self.return_type = return_type.strip() + self.name = name.strip() + self.args = [ParamDecl(arg.strip()) for arg in args.split(',')] + + def gen_list(self, format: str) -> str: + return ', '.join(format.format_map(arg.__dict__) for arg in self.args)scripts/coroutine-wrapper.py
Quoted 10 lines
scripts/coroutine-wrapper.py new file +10
-0+ + def gen_block(self, format: str) -> str: + return '\n'.join(format.format_map(arg.__dict__) for arg in self.args) + + +# Match wrappers declared with a generated_co_wrapper mark +func_decl_re = re.compile(r'^int\s*generated_co_wrapper\s*' + r'(?P<wrapper_name>[a-z][a-z0-9_]*)' + r'\((?P<args>[^)]*)\);$', re.MULTILINE) +Makes sense (requires coroutines to return int, but you fixed that earlier in the series).
scripts/coroutine-wrapper.py
Quoted 9 lines
scripts/coroutine-wrapper.py new file +9
-0+ +def func_decl_iter(text: str) -> Iterator: + for m in func_decl_re.finditer(text): + yield FuncDecl(return_type='int', + name=m.group('wrapper_name'), + args=m.group('args')) + + +def snake_to_camel(func_name: str) -> str:...
Nothing else jumped out at me, so:
Reviewed-by Eric Blake <[email protected]>Still, here's the promised diffs I'm thinking of:
for 4/7
From
8c089d488ed8d9778fd5ee1f18dbc3845e4349f2Mon Sep 17 00:00:00 2001
From: Vladimir Sementsov-Ogievskiy <[email protected]>
Date: Tue, 9 Jun 2020 17:13:26 +0300
Subject: [PATCH] fixup? scripts: addcoroutine-wrapper.pyWorth squashing in to the coroutine generator?
Signed-off-by Eric Blake <[email protected]>--- scripts/coroutine-wrapper.py | 5 ++-- block/block-gen.h | 6 ----- include/block/block.h | 7 ++++++ include/block/generated-co-wrapper.h | 35 ---------------------------- 4 files changed, 10 insertions(+), 43 deletions(-)delete mode 100644
include/block/generated-co-wrapper.hscripts/coroutine-wrapper.py +3
-2@@ -57,7 +57,8 @@ def gen_header(): #include "qemu/osdep.h" #include "block/coroutines.h" -#include "block/block-gen.h"\ +#include "block/block-gen.h" +#include "block/block_int.h"\ """@@ -139,7 +140,7 @@ static void coroutine_fn {name}_entry(void *opaque) s->poll_state.ret = {name}({ func.gen_list('s->{name}') }); s->poll_state.in_progress = false; - bdrv_poll_co__on_exit(); + aio_wait_kick(); }} int {func.name}({ func.gen_list('{decl}') })block/block-gen.h +0
-6@@ -28,12 +28,6 @@ #include "block/block_int.h" -/* This function is called at the end of generated coroutine entries. */ -static inline void bdrv_poll_co__on_exit (void ) -{ - aio_wait_kick(); -} - /* Base structure for argument packing structures */ typedef struct BdrvPollCo { BlockDriverState *bs;include/block/block.h +7
-0@@ -10,6 +10,13 @@ #include "block/blockjob.h" #include "qemu/hbitmap.h" +/* +* generated_co_wrapper +* Function specifier, which does nothing but marking functions to be +* generated by scripts/coroutine-wrapper.py +*/ +#define generated_co_wrapper + /* block.c */ typedef struct BlockDriver BlockDriver; typedef struct BdrvChild BdrvChild;include/block/generated-co-wrapper.h deleted +0
-25@@ -1,35 +0,0 @@ -/* -* Block layer I/O functions -* -* Copyright (c) 2020 Virtuozzo International GmbH -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -*/ - -#ifndef BLOCK_GENERATED_CO_WRAPPER_H
include/block/generated-co-wrapper.h line 35
Quoted 10 lines
include/block/generated-co-wrapper.h deleted +0
-10-#define BLOCK_GENERATED_CO_WRAPPER_H - -/* -* generated_co_wrapper -* Function specifier, which does nothing but marking functions to be -* generated by scripts/coroutine-wrapper.py -*/ -#define generated_co_wrapper - -#endif /* BLOCK_GENERATED_CO_WRAPPER_H */
Note, that because of this line, thunderbird assumes that the following is the signature, and doesn't include into citation when click "reply" (so, I've selected the whole thing, before clicking, to put the following into citation too). Not a big deal of course.
Quoted 24 lines
2.27.0
for 5/7
block/coroutines.h +0
-1@@ -26,7 +26,6 @@ #define BLOCK_COROUTINES_INT_H #include "block/block_int.h" -#include "block/generated-co-wrapper.h" int coroutine_fn bdrv_co_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);include/block/block.h +0
-0
include/block/block.h line 14
Quoted 7 lines
include/block/block.h +0
-1@@ -9,7 +9,6 @@ #include "block/dirty-bitmap.h" #include "block/blockjob.h" #include "qemu/hbitmap.h" -#include "block/generated-co-wrapper.h" /** generated_co_wrapper
Thank! OK, I'll try it and resend.
Signature · 2 lines
Best regards, Vladimir
PATCH v6 5/7 block: generate coroutine-wrapper code
In reply to Vladimir Sementsov-OgievskiyUse code generation implemented in previous commit to generated coroutine wrappers in block.c and block/io.c
--- block/coroutines.h | 7 +- include/block/block.h | 17 ++-- block.c | 73 --------------- block/io.c | 212 ------------------------------------------ 4 files changed, 15 insertions(+), 294 deletions(-)
block/coroutines.h +4 -3
@@ -26,6 +26,7 @@#define BLOCK_COROUTINES_INT_H #include "block/block_int.h" +#include "block/generated-co-wrapper.h" int coroutine_fn bdrv_co_check(BlockDriverState *bs,BdrvCheckResult *res,BdrvCheckMode fix);
@@ -34,7 +35,7 @@ int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp); int coroutine_fnbdrv_co_prwv (BdrvChild *child,int64_t offset,QEMUIOVector *qiov,bool is_write,BdrvRequestFlags flags); -int +int generated_co_wrapperbdrv_prwv (BdrvChild *child,int64_t offset,QEMUIOVector *qiov,bool is_write,BdrvRequestFlags flags);
@@ -47,7 +48,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 +61,7 @@ bdrv_common_block_status_above(BlockDriverState *bs, int coroutine_fnbdrv_co_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos,bool is_read); -int +int generated_co_wrapperbdrv_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos,bool is_read);
include/block/block.h +11 -6
@@ -9,6 +9,7 @@#include "block/dirty-bitmap.h" #include "block/blockjob.h" #include "qemu/hbitmap.h" +#include "block/generated-co-wrapper.h" /* block.c */ typedef struct BlockDriver BlockDriver ;
@@ -398,8 +399,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);
@@ -441,7 +443,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
@@ -464,12 +467,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 );
@@ -484,7 +488,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);
block.c +0 -73
85 lines not on this page · raw message
block/io.c +0 -212
269 lines not on this page · raw message
Signature · 1 line
2.21.0
Re: [PATCH v6 5/7] block: generate coroutine-wrapper code
Quoted 11 lines · Vladimir Sementsov-Ogievskiy
Use code generation implemented in previous commit to generated coroutine wrappers in
block.candblock/io.cSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/coroutines.h | 7 +- include/block/block.h | 17 ++-- block.c | 73 --------------- block/io.c | 212 ------------------------------------------ 4 files changed, 15 insertions(+), 294 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
PATCH v6 6/7 block: drop bdrv_prwv
In reply to Vladimir Sementsov-OgievskiyNow that we are not maintaining boilerplate code for coroutine wrappers, there is no more sense in keeping the extra indirection layer of bdrv_prwv(). Let's drop it and instead generate pure bdrv_preadv() and bdrv_pwritev().
Currently, bdrv_pwritev() and bdrv_preadv() are returning bytes on success, auto generated functions will instead return zero, as their _co_ prototype. Still, it's simple to make the conversion safe: the only external user of bdrv_pwritev() is test-bdrv-drain, and it is comfortable enough with bdrv_co_pwritev() instead. So prototypes are moved to local block/coroutines.h. Next, the only internal use is bdrv_pread() and bdrv_pwrite(), which are modified to return bytes on success.
Of course, it would be great to convert bdrv_pread() and bdrv_pwrite() to return 0 on success. But this requires audit (and probably conversion) of all their users, let's leave it for another day refactoring.
--- block/coroutines.h | 10 ++++----- include/block/block.h | 2 -- block/io.c | 49 ++++++++--------------------------------- tests/test-bdrv-drain.c | 2 +- 4 files changed, 15 insertions(+), 48 deletions(-)
block/coroutines.h +5 -5
@@ -32,12 +32,12 @@ int coroutine_fn bdrv_co_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix); 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 generated_co_wrapper -bdrv_prwv (BdrvChild *child,int64_t offset,QEMUIOVector *qiov, -bool is_write,BdrvRequestFlags flags); +bdrv_preadv (BdrvChild *child,int64_t offset,unsigned int bytes, +QEMUIOVector *qiov,BdrvRequestFlags flags); +int generated_co_wrapper +bdrv_pwritev (BdrvChild *child,int64_t offset,unsigned int bytes, +QEMUIOVector *qiov,BdrvRequestFlags flags); int coroutine_fn bdrv_co_common_block_status_above(BlockDriverState *bs,
include/block/block.h +0 -2
@@ -379,9 +379,7 @@ int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset, int bytes, BdrvRequestFlags flags);int bdrv_make_zero (BdrvChild *child,BdrvRequestFlags flags);int bdrv_pread (BdrvChild *child,int64_t offset,void *buf,int bytes); -int bdrv_preadv (BdrvChild *child,int64_t offset,QEMUIOVector *qiov);int bdrv_pwrite (BdrvChild *child,int64_t offset,const void *buf,int bytes); -int bdrv_pwritev (BdrvChild *child,int64_t offset,QEMUIOVector *qiov);int bdrv_pwrite_sync (BdrvChild *child,int64_t offset,const void *buf,int count);/*
block/io.c +9 -40
86 lines not on this page · raw message
tests/test-bdrv-drain.c +1 -1
@@ -1872,7 +1872,7 @@ static int coroutine_fn bdrv_replace_test_co_preadv(BlockDriverState *bs, } s->io_co =NULL ; - ret =bdrv_preadv (bs->backing, offset, qiov); + ret =bdrv_co_preadv (bs->backing, offset, bytes, qiov,0 ); s->has_read = true;/* Wake up drain_co if it runs */
Signature · 1 line
2.21.0
PATCH v6 7/7 block/io: refactor save/load vmstate
In reply to Vladimir Sementsov-OgievskiyLike for read/write in a previous commit, drop extra indirection layer, generate directly bdrv_readv_vmstate() and bdrv_writev_vmstate().
--- block/coroutines.h | 10 +++---- include/block/block.h | 6 ++-- block/io.c | 67 ++++++++++++++++++++++--------------------- 3 files changed, 42 insertions(+), 41 deletions(-)
block/coroutines.h +4 -6
@@ -58,11 +58,9 @@ bdrv_common_block_status_above(BlockDriverState *bs,int64_t *map, BlockDriverState **file); -int coroutine_fn -bdrv_co_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos, -bool is_read); -int generated_co_wrapper -bdrv_rw_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos, -bool is_read); +int coroutine_fn bdrv_co_readv_vmstate(BlockDriverState *bs, +QEMUIOVector *qiov,int64_t pos); +int coroutine_fn bdrv_co_writev_vmstate(BlockDriverState *bs, +QEMUIOVector *qiov,int64_t pos);#endif /* BLOCK_COROUTINES_INT_H */
include/block/block.h +4 -2
@@ -568,8 +568,10 @@ int path_has_protocol(const char *path);int path_is_absolute (const char *path);char *path_combine (const char *base_path,const char *filename); -int bdrv_readv_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos); -int bdrv_writev_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos); +int generated_co_wrapper +bdrv_readv_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos); +int generated_co_wrapper +bdrv_writev_vmstate (BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos);int bdrv_save_vmstate (BlockDriverState *bs,const uint8_t *buf,int64_t pos,int size);
block/io.c +34 -33
100 lines not on this page · raw message
Signature · 1 line
2.21.0