1#! /usr/bin/env python3
2"""Generate coroutine wrappers for block subsystem.
3
4The program parses one or several concatenated c files from stdin,
5searches for functions with the 'co_wrapper' specifier
6and generates corresponding wrappers on stdout.
7
8Usage: block-coroutine-wrapper.py generated-file.c FILE.[ch]...
9
10Copyright (c) 2020 Virtuozzo International GmbH.
11
12This program is free software; you can redistribute it and/or modify
13it under the terms of the GNU General Public License as published by
14the Free Software Foundation; either version 2 of the License, or
15(at your option) any later version.
16
17This program is distributed in the hope that it will be useful,
18but WITHOUT ANY WARRANTY; without even the implied warranty of
19MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20GNU General Public License for more details.
21
22You should have received a copy of the GNU General Public License
23along with this program.  If not, see <http://www.gnu.org/licenses/>.
24"""
25
26import sys
27import re
28from typing import Iterator
29
30
31def gen_header():
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)
35    return f"""\
36/*
37 * File is generated by scripts/block-coroutine-wrapper.py
38 *
39{copyright}
40 */
41
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"
47"""
48
49
50class ParamDecl:
51    param_re = re.compile(r'(?P<decl>'
52                          r'(?P<type>.*[ *])'
53                          r'(?P<name>[a-z][a-z0-9_]*)'
54                          r')')
55
56    def __init__(self, param_decl: str) -> None:
57        m = self.param_re.match(param_decl.strip())
58        if m is None:
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')
63
64
65class FuncDecl:
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
75
76        self.wrapper_type = wrapper_type
77
78        if wrapper_type == 'co':
79            if self.graph_wrlock:
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}'
83        else:
84            assert wrapper_type == 'no_co'
85            subsystem, co_infix, subname = self.name.split('_', 2)
86            if co_infix != 'co':
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}")
90            if self.graph_rdlock and self.graph_wrlock:
91                raise ValueError("function can't be both rdlock and wrlock: "
92                                 f"{self.name}")
93            self.target_name = f'{subsystem}_{subname}'
94
95        self.ctx = self.gen_ctx()
96
97        self.get_result = 's->ret = '
98        self.ret = 'return s.ret;'
99        self.co_ret = 'return '
100        self.return_field = self.return_type + " ret;"
101        if self.return_type == 'void':
102            self.get_result = ''
103            self.ret = ''
104            self.co_ret = ''
105            self.return_field = ''
106
107    def gen_ctx(self, prefix: str = '') -> str:
108        t = self.args[0].type
109        name = self.args[0].name
110        if t == 'BlockDriverState *':
111            return f'bdrv_get_aio_context({prefix}{name})'
112        elif t == 'BdrvChild *':
113            return f'bdrv_get_aio_context({prefix}{name}->bs)'
114        elif t == 'BlockBackend *':
115            return f'blk_get_aio_context({prefix}{name})'
116        else:
117            return 'qemu_get_aio_context()'
118
119    def gen_list(self, format: str) -> str:
120        return ', '.join(format.format_map(arg.__dict__) for arg in self.args)
121
122    def gen_block(self, format: str) -> str:
123        return '\n'.join(format.format_map(arg.__dict__) for arg in self.args)
124
125
126# Match wrappers declared with a co_wrapper mark
127func_decl_re = re.compile(r'^(?P<return_type>[a-zA-Z][a-zA-Z0-9_]* [\*]?)'
128                          r'(\s*coroutine_fn)?'
129                          r'\s*(?P<wrapper_type>(no_)?co)_wrapper'
130                          r'(?P<variant>(_[a-z][a-z0-9_]*)?)\s*'
131                          r'(?P<wrapper_name>[a-z][a-z0-9_]*)'
132                          r'\((?P<args>[^)]*)\);$', re.MULTILINE)
133
134
135def func_decl_iter(text: str) -> Iterator:
136    for m in func_decl_re.finditer(text):
137        yield FuncDecl(wrapper_type=m.group('wrapper_type'),
138                       return_type=m.group('return_type'),
139                       name=m.group('wrapper_name'),
140                       args=m.group('args'),
141                       variant=m.group('variant'))
142
143
144def snake_to_camel(func_name: str) -> str:
145    """
146    Convert underscore names like 'some_function_name' to camel-case like
147    'SomeFunctionName'
148    """
149    words = func_name.split('_')
150    words = [w[0].upper() + w[1:] for w in words]
151    return ''.join(words)
152
153
154def create_mixed_wrapper(func: FuncDecl) -> str:
155    """
156    Checks if we are already in coroutine
157    """
158    name = func.target_name
159    struct_name = func.struct_name
160    graph_assume_lock = 'assume_graph_lock();' if func.graph_rdlock else ''
161
162    return f"""\
163{func.return_type} {func.name}({ func.gen_list('{decl}') })
164{{
165    if (qemu_in_coroutine()) {{
166        {graph_assume_lock}
167        {func.co_ret}{name}({ func.gen_list('{name}') });
168    }} else {{
169        {struct_name} s = {{
170            .poll_state.ctx = {func.ctx},
171            .poll_state.in_progress = true,
172
173{ func.gen_block('            .{name} = {name},') }
174        }};
175
176        s.poll_state.co = qemu_coroutine_create({name}_entry, &s);
177
178        bdrv_poll_co(&s.poll_state);
179        {func.ret}
180    }}
181}}"""
182
183
184def create_co_wrapper(func: FuncDecl) -> str:
185    """
186    Assumes we are not in coroutine, and creates one
187    """
188    name = func.target_name
189    struct_name = func.struct_name
190    return f"""\
191{func.return_type} {func.name}({ func.gen_list('{decl}') })
192{{
193    {struct_name} s = {{
194        .poll_state.ctx = {func.ctx},
195        .poll_state.in_progress = true,
196
197{ func.gen_block('        .{name} = {name},') }
198    }};
199    assert(!qemu_in_coroutine());
200
201    s.poll_state.co = qemu_coroutine_create({name}_entry, &s);
202
203    bdrv_poll_co(&s.poll_state);
204    {func.ret}
205}}"""
206
207
208def gen_co_wrapper(func: FuncDecl) -> str:
209    assert not '_co_' in func.name
210    assert func.wrapper_type == 'co'
211
212    name = func.target_name
213    struct_name = func.struct_name
214
215    graph_lock=''
216    graph_unlock=''
217    if func.graph_rdlock:
218        graph_lock='    bdrv_graph_co_rdlock();'
219        graph_unlock='    bdrv_graph_co_rdunlock();'
220
221    creation_function = create_mixed_wrapper
222    if func.create_only_co:
223        creation_function = create_co_wrapper
224
225    return f"""\
226/*
227 * Wrappers for {name}
228 */
229
230typedef struct {struct_name} {{
231    BdrvPollCo poll_state;
232    {func.return_field}
233{ func.gen_block('    {decl};') }
234}} {struct_name};
235
236static void coroutine_fn {name}_entry(void *opaque)
237{{
238    {struct_name} *s = opaque;
239
240{graph_lock}
241    {func.get_result}{name}({ func.gen_list('s->{name}') });
242{graph_unlock}
243    s->poll_state.in_progress = false;
244
245    aio_wait_kick();
246}}
247
248{creation_function(func)}"""
249
250
251def gen_no_co_wrapper(func: FuncDecl) -> str:
252    assert '_co_' in func.name
253    assert func.wrapper_type == 'no_co'
254
255    name = func.target_name
256    struct_name = func.struct_name
257
258    graph_lock=''
259    graph_unlock=''
260    if func.graph_rdlock:
261        graph_lock='    bdrv_graph_rdlock_main_loop();'
262        graph_unlock='    bdrv_graph_rdunlock_main_loop();'
263    elif func.graph_wrlock:
264        graph_lock='    bdrv_graph_wrlock(NULL);'
265        graph_unlock='    bdrv_graph_wrunlock(NULL);'
266
267    return f"""\
268/*
269 * Wrappers for {name}
270 */
271
272typedef struct {struct_name} {{
273    Coroutine *co;
274    {func.return_field}
275{ func.gen_block('    {decl};') }
276}} {struct_name};
277
278static void {name}_bh(void *opaque)
279{{
280    {struct_name} *s = opaque;
281    AioContext *ctx = {func.gen_ctx('s->')};
282
283{graph_lock}
284    aio_context_acquire(ctx);
285    {func.get_result}{name}({ func.gen_list('s->{name}') });
286    aio_context_release(ctx);
287{graph_unlock}
288
289    aio_co_wake(s->co);
290}}
291
292{func.return_type} coroutine_fn {func.name}({ func.gen_list('{decl}') })
293{{
294    {struct_name} s = {{
295        .co = qemu_coroutine_self(),
296{ func.gen_block('        .{name} = {name},') }
297    }};
298    assert(qemu_in_coroutine());
299
300    aio_bh_schedule_oneshot(qemu_get_aio_context(), {name}_bh, &s);
301    qemu_coroutine_yield();
302
303    {func.ret}
304}}"""
305
306
307def gen_wrappers(input_code: str) -> str:
308    res = ''
309    for func in func_decl_iter(input_code):
310        res += '\n\n\n'
311        if func.wrapper_type == 'co':
312            res += gen_co_wrapper(func)
313        else:
314            res += gen_no_co_wrapper(func)
315
316    return res
317
318
319if __name__ == '__main__':
320    if len(sys.argv) < 3:
321        exit(f'Usage: {sys.argv[0]} OUT_FILE.c IN_FILE.[ch]...')
322
323    with open(sys.argv[1], 'w', encoding='utf-8') as f_out:
324        f_out.write(gen_header())
325        for fname in sys.argv[2:]:
326            with open(fname, encoding='utf-8') as f_in:
327                f_out.write(gen_wrappers(f_in.read()))
328                f_out.write('\n')
329