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