]>
Commit | Line | Data |
---|---|---|
c0c071d0 PD |
1 | /* |
2 | * replay-events.c | |
3 | * | |
4 | * Copyright (c) 2010-2015 Institute for System Programming | |
5 | * of the Russian Academy of Sciences. | |
6 | * | |
7 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
8 | * See the COPYING file in the top-level directory. | |
9 | * | |
10 | */ | |
11 | ||
d38ea87a | 12 | #include "qemu/osdep.h" |
c0c071d0 PD |
13 | #include "qemu/error-report.h" |
14 | #include "sysemu/replay.h" | |
15 | #include "replay-internal.h" | |
8a354bd9 | 16 | #include "block/aio.h" |
ee312992 | 17 | #include "ui/input.h" |
c0c071d0 PD |
18 | |
19 | typedef struct Event { | |
20 | ReplayAsyncEventKind event_kind; | |
21 | void *opaque; | |
22 | void *opaque2; | |
23 | uint64_t id; | |
24 | ||
25 | QTAILQ_ENTRY(Event) events; | |
26 | } Event; | |
27 | ||
28 | static QTAILQ_HEAD(, Event) events_list = QTAILQ_HEAD_INITIALIZER(events_list); | |
c0c071d0 PD |
29 | static bool events_enabled; |
30 | ||
31 | /* Functions */ | |
32 | ||
33 | static void replay_run_event(Event *event) | |
34 | { | |
35 | switch (event->event_kind) { | |
8a354bd9 PD |
36 | case REPLAY_ASYNC_EVENT_BH: |
37 | aio_bh_call(event->opaque); | |
38 | break; | |
e4ec5ad4 PD |
39 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
40 | ((QEMUBHFunc *)event->opaque)(event->opaque2); | |
41 | break; | |
ee312992 PD |
42 | case REPLAY_ASYNC_EVENT_INPUT: |
43 | qemu_input_event_send_impl(NULL, (InputEvent *)event->opaque); | |
44 | qapi_free_InputEvent((InputEvent *)event->opaque); | |
45 | break; | |
46 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: | |
47 | qemu_input_event_sync_impl(); | |
48 | break; | |
33577b47 PD |
49 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
50 | replay_event_char_read_run(event->opaque); | |
51 | break; | |
63785678 PD |
52 | case REPLAY_ASYNC_EVENT_BLOCK: |
53 | aio_bh_call(event->opaque); | |
54 | break; | |
646c5478 PD |
55 | case REPLAY_ASYNC_EVENT_NET: |
56 | replay_event_net_run(event->opaque); | |
57 | break; | |
c0c071d0 PD |
58 | default: |
59 | error_report("Replay: invalid async event ID (%d) in the queue", | |
60 | event->event_kind); | |
61 | exit(1); | |
62 | break; | |
63 | } | |
64 | } | |
65 | ||
66 | void replay_enable_events(void) | |
67 | { | |
1652e0c3 PD |
68 | if (replay_mode != REPLAY_MODE_NONE) { |
69 | events_enabled = true; | |
70 | } | |
c0c071d0 PD |
71 | } |
72 | ||
73 | bool replay_has_events(void) | |
74 | { | |
75 | return !QTAILQ_EMPTY(&events_list); | |
76 | } | |
77 | ||
78 | void replay_flush_events(void) | |
79 | { | |
f9a9fb65 PD |
80 | if (replay_mode == REPLAY_MODE_NONE) { |
81 | return; | |
82 | } | |
83 | ||
d759c951 AB |
84 | g_assert(replay_mutex_locked()); |
85 | ||
c0c071d0 PD |
86 | while (!QTAILQ_EMPTY(&events_list)) { |
87 | Event *event = QTAILQ_FIRST(&events_list); | |
c0c071d0 | 88 | replay_run_event(event); |
c0c071d0 PD |
89 | QTAILQ_REMOVE(&events_list, event, events); |
90 | g_free(event); | |
91 | } | |
c0c071d0 PD |
92 | } |
93 | ||
94 | void replay_disable_events(void) | |
95 | { | |
96 | if (replay_mode != REPLAY_MODE_NONE) { | |
97 | events_enabled = false; | |
98 | /* Flush events queue before waiting of completion */ | |
99 | replay_flush_events(); | |
100 | } | |
101 | } | |
102 | ||
c0c071d0 | 103 | /*! Adds specified async event to the queue */ |
33577b47 PD |
104 | void replay_add_event(ReplayAsyncEventKind event_kind, |
105 | void *opaque, | |
106 | void *opaque2, uint64_t id) | |
c0c071d0 PD |
107 | { |
108 | assert(event_kind < REPLAY_ASYNC_COUNT); | |
109 | ||
110 | if (!replay_file || replay_mode == REPLAY_MODE_NONE | |
111 | || !events_enabled) { | |
112 | Event e; | |
113 | e.event_kind = event_kind; | |
114 | e.opaque = opaque; | |
115 | e.opaque2 = opaque2; | |
116 | e.id = id; | |
117 | replay_run_event(&e); | |
118 | return; | |
119 | } | |
120 | ||
121 | Event *event = g_malloc0(sizeof(Event)); | |
122 | event->event_kind = event_kind; | |
123 | event->opaque = opaque; | |
124 | event->opaque2 = opaque2; | |
125 | event->id = id; | |
126 | ||
d759c951 | 127 | g_assert(replay_mutex_locked()); |
c0c071d0 | 128 | QTAILQ_INSERT_TAIL(&events_list, event, events); |
c0c071d0 | 129 | } |
8a354bd9 PD |
130 | |
131 | void replay_bh_schedule_event(QEMUBH *bh) | |
132 | { | |
1652e0c3 | 133 | if (events_enabled) { |
13f26713 | 134 | uint64_t id = replay_get_current_icount(); |
8a354bd9 PD |
135 | replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id); |
136 | } else { | |
137 | qemu_bh_schedule(bh); | |
138 | } | |
139 | } | |
c0c071d0 | 140 | |
e4ec5ad4 PD |
141 | void replay_bh_schedule_oneshot_event(AioContext *ctx, |
142 | QEMUBHFunc *cb, void *opaque) | |
143 | { | |
144 | if (events_enabled) { | |
145 | uint64_t id = replay_get_current_icount(); | |
146 | replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id); | |
147 | } else { | |
148 | aio_bh_schedule_oneshot(ctx, cb, opaque); | |
149 | } | |
150 | } | |
151 | ||
ee312992 PD |
152 | void replay_add_input_event(struct InputEvent *event) |
153 | { | |
154 | replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0); | |
155 | } | |
156 | ||
157 | void replay_add_input_sync_event(void) | |
158 | { | |
159 | replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0); | |
160 | } | |
161 | ||
63785678 PD |
162 | void replay_block_event(QEMUBH *bh, uint64_t id) |
163 | { | |
1652e0c3 | 164 | if (events_enabled) { |
63785678 PD |
165 | replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id); |
166 | } else { | |
167 | qemu_bh_schedule(bh); | |
168 | } | |
169 | } | |
170 | ||
c0c071d0 PD |
171 | static void replay_save_event(Event *event, int checkpoint) |
172 | { | |
173 | if (replay_mode != REPLAY_MODE_PLAY) { | |
174 | /* put the event into the file */ | |
175 | replay_put_event(EVENT_ASYNC); | |
176 | replay_put_byte(checkpoint); | |
177 | replay_put_byte(event->event_kind); | |
178 | ||
179 | /* save event-specific data */ | |
180 | switch (event->event_kind) { | |
8a354bd9 | 181 | case REPLAY_ASYNC_EVENT_BH: |
e4ec5ad4 | 182 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
8a354bd9 PD |
183 | replay_put_qword(event->id); |
184 | break; | |
ee312992 PD |
185 | case REPLAY_ASYNC_EVENT_INPUT: |
186 | replay_save_input_event(event->opaque); | |
187 | break; | |
188 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: | |
189 | break; | |
33577b47 PD |
190 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
191 | replay_event_char_read_save(event->opaque); | |
192 | break; | |
63785678 PD |
193 | case REPLAY_ASYNC_EVENT_BLOCK: |
194 | replay_put_qword(event->id); | |
195 | break; | |
646c5478 PD |
196 | case REPLAY_ASYNC_EVENT_NET: |
197 | replay_event_net_save(event->opaque); | |
198 | break; | |
c0c071d0 | 199 | default: |
95b4aed5 | 200 | error_report("Unknown ID %" PRId64 " of replay event", event->id); |
c0c071d0 | 201 | exit(1); |
c0c071d0 PD |
202 | } |
203 | } | |
204 | } | |
205 | ||
206 | /* Called with replay mutex locked */ | |
207 | void replay_save_events(int checkpoint) | |
208 | { | |
d759c951 | 209 | g_assert(replay_mutex_locked()); |
89e46eb4 | 210 | g_assert(checkpoint != CHECKPOINT_CLOCK_WARP_START); |
ca9759c2 | 211 | g_assert(checkpoint != CHECKPOINT_CLOCK_VIRTUAL); |
c0c071d0 PD |
212 | while (!QTAILQ_EMPTY(&events_list)) { |
213 | Event *event = QTAILQ_FIRST(&events_list); | |
214 | replay_save_event(event, checkpoint); | |
c0c071d0 | 215 | replay_run_event(event); |
c0c071d0 PD |
216 | QTAILQ_REMOVE(&events_list, event, events); |
217 | g_free(event); | |
218 | } | |
219 | } | |
220 | ||
221 | static Event *replay_read_event(int checkpoint) | |
222 | { | |
223 | Event *event; | |
0b30dc01 PD |
224 | if (replay_state.read_event_kind == -1) { |
225 | replay_state.read_event_checkpoint = replay_get_byte(); | |
226 | replay_state.read_event_kind = replay_get_byte(); | |
227 | replay_state.read_event_id = -1; | |
c0c071d0 PD |
228 | replay_check_error(); |
229 | } | |
230 | ||
0b30dc01 | 231 | if (checkpoint != replay_state.read_event_checkpoint) { |
c0c071d0 PD |
232 | return NULL; |
233 | } | |
234 | ||
235 | /* Events that has not to be in the queue */ | |
0b30dc01 | 236 | switch (replay_state.read_event_kind) { |
8a354bd9 | 237 | case REPLAY_ASYNC_EVENT_BH: |
e4ec5ad4 | 238 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
0b30dc01 PD |
239 | if (replay_state.read_event_id == -1) { |
240 | replay_state.read_event_id = replay_get_qword(); | |
8a354bd9 PD |
241 | } |
242 | break; | |
ee312992 PD |
243 | case REPLAY_ASYNC_EVENT_INPUT: |
244 | event = g_malloc0(sizeof(Event)); | |
0b30dc01 | 245 | event->event_kind = replay_state.read_event_kind; |
ee312992 PD |
246 | event->opaque = replay_read_input_event(); |
247 | return event; | |
248 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: | |
249 | event = g_malloc0(sizeof(Event)); | |
0b30dc01 | 250 | event->event_kind = replay_state.read_event_kind; |
ee312992 PD |
251 | event->opaque = 0; |
252 | return event; | |
33577b47 PD |
253 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
254 | event = g_malloc0(sizeof(Event)); | |
0b30dc01 | 255 | event->event_kind = replay_state.read_event_kind; |
33577b47 PD |
256 | event->opaque = replay_event_char_read_load(); |
257 | return event; | |
63785678 | 258 | case REPLAY_ASYNC_EVENT_BLOCK: |
0b30dc01 PD |
259 | if (replay_state.read_event_id == -1) { |
260 | replay_state.read_event_id = replay_get_qword(); | |
63785678 PD |
261 | } |
262 | break; | |
646c5478 PD |
263 | case REPLAY_ASYNC_EVENT_NET: |
264 | event = g_malloc0(sizeof(Event)); | |
0b30dc01 | 265 | event->event_kind = replay_state.read_event_kind; |
646c5478 PD |
266 | event->opaque = replay_event_net_load(); |
267 | return event; | |
c0c071d0 | 268 | default: |
0b30dc01 PD |
269 | error_report("Unknown ID %d of replay event", |
270 | replay_state.read_event_kind); | |
c0c071d0 PD |
271 | exit(1); |
272 | break; | |
273 | } | |
274 | ||
275 | QTAILQ_FOREACH(event, &events_list, events) { | |
0b30dc01 PD |
276 | if (event->event_kind == replay_state.read_event_kind |
277 | && (replay_state.read_event_id == -1 | |
278 | || replay_state.read_event_id == event->id)) { | |
c0c071d0 PD |
279 | break; |
280 | } | |
281 | } | |
282 | ||
283 | if (event) { | |
284 | QTAILQ_REMOVE(&events_list, event, events); | |
285 | } else { | |
286 | return NULL; | |
287 | } | |
288 | ||
289 | /* Read event-specific data */ | |
290 | ||
291 | return event; | |
292 | } | |
293 | ||
294 | /* Called with replay mutex locked */ | |
295 | void replay_read_events(int checkpoint) | |
296 | { | |
d759c951 | 297 | g_assert(replay_mutex_locked()); |
f186d64d | 298 | while (replay_state.data_kind == EVENT_ASYNC) { |
c0c071d0 PD |
299 | Event *event = replay_read_event(checkpoint); |
300 | if (!event) { | |
301 | break; | |
302 | } | |
1a96e3c1 | 303 | replay_finish_event(); |
0b30dc01 | 304 | replay_state.read_event_kind = -1; |
c0c071d0 | 305 | replay_run_event(event); |
c0c071d0 PD |
306 | |
307 | g_free(event); | |
c0c071d0 PD |
308 | } |
309 | } | |
310 | ||
311 | void replay_init_events(void) | |
312 | { | |
0b30dc01 | 313 | replay_state.read_event_kind = -1; |
c0c071d0 PD |
314 | } |
315 | ||
316 | void replay_finish_events(void) | |
317 | { | |
318 | events_enabled = false; | |
d873fe03 | 319 | replay_flush_events(); |
c0c071d0 PD |
320 | } |
321 | ||
322 | bool replay_events_enabled(void) | |
323 | { | |
324 | return events_enabled; | |
325 | } | |
6d0ceb80 PD |
326 | |
327 | uint64_t blkreplay_next_id(void) | |
328 | { | |
329 | if (replay_events_enabled()) { | |
330 | return replay_state.block_request_id++; | |
331 | } | |
332 | return 0; | |
333 | } |