1 #! /usr/bin/env python3
2 """Generate coroutine wrappers for block subsystem.
4 The program parses one or several concatenated c files from stdin,
5 searches for functions with the 'co_wrapper' specifier
6 and generates corresponding wrappers on stdout.
8 Usage: block-coroutine-wrapper.py generated-file.c FILE.[ch]...
10 Copyright (c) 2020 Virtuozzo International GmbH.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
28 from typing
import Iterator
32 copyright
= re
.sub('^.*Copyright', 'Copyright', __doc__
, flags
=re
.DOTALL
)
33 copyright
= re
.sub('^(?=.)', ' * ', copyright
.strip(), flags
=re
.MULTILINE
)
34 copyright
= re
.sub('^$', ' *', copyright
, flags
=re
.MULTILINE
)
37 * File is generated by scripts/block-coroutine-wrapper.py
42 #include "qemu/osdep.h"
43 #include "block/coroutines.h"
44 #include "block/block-gen.h"
45 #include "block/block_int.h"
46 #include "block/dirty-bitmap.h"
51 param_re
= re
.compile(r
'(?P<decl>'
53 r
'(?P<name>[a-z][a-z0-9_]*)'
56 def __init__(self
, param_decl
: str) -> None:
57 m
= self
.param_re
.match(param_decl
.strip())
59 raise ValueError(f
'Wrong parameter declaration: "{param_decl}"')
60 self
.decl
= m
.group('decl')
61 self
.type = m
.group('type')
62 self
.name
= m
.group('name')
66 def __init__(self
, wrapper_type
: str, return_type
: str, name
: str,
67 args
: str, variant
: str) -> None:
68 self
.return_type
= return_type
.strip()
69 self
.name
= name
.strip()
70 self
.struct_name
= snake_to_camel(self
.name
)
71 self
.args
= [ParamDecl(arg
.strip()) for arg
in args
.split(',')]
72 self
.create_only_co
= 'mixed' not in variant
73 self
.graph_rdlock
= 'bdrv_rdlock' in variant
74 self
.graph_wrlock
= 'bdrv_wrlock' in variant
76 self
.wrapper_type
= wrapper_type
78 if wrapper_type
== 'co':
80 raise ValueError(f
"co function can't be wrlock: {self.name}")
81 subsystem
, subname
= self
.name
.split('_', 1)
82 self
.target_name
= f
'{subsystem}_co_{subname}'
84 assert wrapper_type
== 'no_co'
85 subsystem
, co_infix
, subname
= self
.name
.split('_', 2)
87 raise ValueError(f
"Invalid no_co function name: {self.name}")
88 if not self
.create_only_co
:
89 raise ValueError(f
"no_co function can't be mixed: {self.name}")
91 raise ValueError(f
"no_co function can't be rdlock: {self.name}")
92 self
.target_name
= f
'{subsystem}_{subname}'
94 self
.ctx
= self
.gen_ctx()
96 self
.get_result
= 's->ret = '
97 self
.ret
= 'return s.ret;'
98 self
.co_ret
= 'return '
99 self
.return_field
= self
.return_type
+ " ret;"
100 if self
.return_type
== 'void':
104 self
.return_field
= ''
106 def gen_ctx(self
, prefix
: str = '') -> str:
107 t
= self
.args
[0].type
108 name
= self
.args
[0].name
109 if t
== 'BlockDriverState *':
110 return f
'bdrv_get_aio_context({prefix}{name})'
111 elif t
== 'BdrvChild *':
112 return f
'bdrv_get_aio_context({prefix}{name}->bs)'
113 elif t
== 'BlockBackend *':
114 return f
'blk_get_aio_context({prefix}{name})'
116 return 'qemu_get_aio_context()'
118 def gen_list(self
, format
: str) -> str:
119 return ', '.join(format
.format_map(arg
.__dict
__) for arg
in self
.args
)
121 def gen_block(self
, format
: str) -> str:
122 return '\n'.join(format
.format_map(arg
.__dict
__) for arg
in self
.args
)
125 # Match wrappers declared with a co_wrapper mark
126 func_decl_re
= re
.compile(r
'^(?P<return_type>[a-zA-Z][a-zA-Z0-9_]* [\*]?)'
127 r
'(\s*coroutine_fn)?'
128 r
'\s*(?P<wrapper_type>(no_)?co)_wrapper'
129 r
'(?P<variant>(_[a-z][a-z0-9_]*)?)\s*'
130 r
'(?P<wrapper_name>[a-z][a-z0-9_]*)'
131 r
'\((?P<args>[^)]*)\);$', re
.MULTILINE
)
134 def func_decl_iter(text
: str) -> Iterator
:
135 for m
in func_decl_re
.finditer(text
):
136 yield FuncDecl(wrapper_type
=m
.group('wrapper_type'),
137 return_type
=m
.group('return_type'),
138 name
=m
.group('wrapper_name'),
139 args
=m
.group('args'),
140 variant
=m
.group('variant'))
143 def snake_to_camel(func_name
: str) -> str:
145 Convert underscore names like 'some_function_name' to camel-case like
148 words
= func_name
.split('_')
149 words
= [w
[0].upper() + w
[1:] for w
in words
]
150 return ''.join(words
)
153 def create_mixed_wrapper(func
: FuncDecl
) -> str:
155 Checks if we are already in coroutine
157 name
= func
.target_name
158 struct_name
= func
.struct_name
159 graph_assume_lock
= 'assume_graph_lock();' if func
.graph_rdlock
else ''
162 {func.return_type} {func.name}({ func.gen_list('{decl}') })
164 if (qemu_in_coroutine()) {{
166 {func.co_ret}{name}({ func.gen_list('{name}') });
169 .poll_state.ctx = {func.ctx},
170 .poll_state.in_progress = true,
172 { func.gen_block(' .{name} = {name},') }
175 s.poll_state.co = qemu_coroutine_create({name}_entry, &s);
177 bdrv_poll_co(&s.poll_state);
183 def create_co_wrapper(func
: FuncDecl
) -> str:
185 Assumes we are not in coroutine, and creates one
187 name
= func
.target_name
188 struct_name
= func
.struct_name
190 {func.return_type} {func.name}({ func.gen_list('{decl}') })
193 .poll_state.ctx = {func.ctx},
194 .poll_state.in_progress = true,
196 { func.gen_block(' .{name} = {name},') }
198 assert(!qemu_in_coroutine());
200 s.poll_state.co = qemu_coroutine_create({name}_entry, &s);
202 bdrv_poll_co(&s.poll_state);
207 def gen_co_wrapper(func
: FuncDecl
) -> str:
208 assert not '_co_' in func
.name
209 assert func
.wrapper_type
== 'co'
211 name
= func
.target_name
212 struct_name
= func
.struct_name
216 if func
.graph_rdlock
:
217 graph_lock
=' bdrv_graph_co_rdlock();'
218 graph_unlock
=' bdrv_graph_co_rdunlock();'
220 creation_function
= create_mixed_wrapper
221 if func
.create_only_co
:
222 creation_function
= create_co_wrapper
226 * Wrappers for {name}
229 typedef struct {struct_name} {{
230 BdrvPollCo poll_state;
232 { func.gen_block(' {decl};') }
235 static void coroutine_fn {name}_entry(void *opaque)
237 {struct_name} *s = opaque;
240 {func.get_result}{name}({ func.gen_list('s->{name}') });
242 s->poll_state.in_progress = false;
247 {creation_function(func)}"""
250 def gen_no_co_wrapper(func
: FuncDecl
) -> str:
251 assert '_co_' in func
.name
252 assert func
.wrapper_type
== 'no_co'
254 name
= func
.target_name
255 struct_name
= func
.struct_name
259 if func
.graph_wrlock
:
260 graph_lock
=' bdrv_graph_wrlock(NULL);'
261 graph_unlock
=' bdrv_graph_wrunlock();'
265 * Wrappers for {name}
268 typedef struct {struct_name} {{
271 { func.gen_block(' {decl};') }
274 static void {name}_bh(void *opaque)
276 {struct_name} *s = opaque;
277 AioContext *ctx = {func.gen_ctx('s->')};
280 aio_context_acquire(ctx);
281 {func.get_result}{name}({ func.gen_list('s->{name}') });
282 aio_context_release(ctx);
288 {func.return_type} coroutine_fn {func.name}({ func.gen_list('{decl}') })
291 .co = qemu_coroutine_self(),
292 { func.gen_block(' .{name} = {name},') }
294 assert(qemu_in_coroutine());
296 aio_bh_schedule_oneshot(qemu_get_aio_context(), {name}_bh, &s);
297 qemu_coroutine_yield();
303 def gen_wrappers(input_code
: str) -> str:
305 for func
in func_decl_iter(input_code
):
307 if func
.wrapper_type
== 'co':
308 res
+= gen_co_wrapper(func
)
310 res
+= gen_no_co_wrapper(func
)
315 if __name__
== '__main__':
316 if len(sys
.argv
) < 3:
317 exit(f
'Usage: {sys.argv[0]} OUT_FILE.c IN_FILE.[ch]...')
319 with
open(sys
.argv
[1], 'w', encoding
='utf-8') as f_out
:
320 f_out
.write(gen_header())
321 for fname
in sys
.argv
[2:]:
322 with
open(fname
, encoding
='utf-8') as f_in
:
323 f_out
.write(gen_wrappers(f_in
.read()))