]>
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 | ||
b21e2380 | 122 | Event *event = g_new0(Event, 1); |
c0c071d0 PD |
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 | ||
60618e2d | 173 | static void replay_save_event(Event *event) |
c0c071d0 PD |
174 | { |
175 | if (replay_mode != REPLAY_MODE_PLAY) { | |
176 | /* put the event into the file */ | |
3e21408b PD |
177 | g_assert(event->event_kind < REPLAY_ASYNC_COUNT); |
178 | replay_put_event(EVENT_ASYNC + event->event_kind); | |
c0c071d0 PD |
179 | |
180 | /* save event-specific data */ | |
181 | switch (event->event_kind) { | |
8a354bd9 | 182 | case REPLAY_ASYNC_EVENT_BH: |
e4ec5ad4 | 183 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
8a354bd9 PD |
184 | replay_put_qword(event->id); |
185 | break; | |
ee312992 PD |
186 | case REPLAY_ASYNC_EVENT_INPUT: |
187 | replay_save_input_event(event->opaque); | |
188 | break; | |
189 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: | |
190 | break; | |
33577b47 PD |
191 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
192 | replay_event_char_read_save(event->opaque); | |
193 | break; | |
63785678 PD |
194 | case REPLAY_ASYNC_EVENT_BLOCK: |
195 | replay_put_qword(event->id); | |
196 | break; | |
646c5478 PD |
197 | case REPLAY_ASYNC_EVENT_NET: |
198 | replay_event_net_save(event->opaque); | |
199 | break; | |
c0c071d0 | 200 | default: |
95b4aed5 | 201 | error_report("Unknown ID %" PRId64 " of replay event", event->id); |
c0c071d0 | 202 | exit(1); |
c0c071d0 PD |
203 | } |
204 | } | |
205 | } | |
206 | ||
207 | /* Called with replay mutex locked */ | |
60618e2d | 208 | void replay_save_events(void) |
c0c071d0 | 209 | { |
d759c951 | 210 | g_assert(replay_mutex_locked()); |
c0c071d0 PD |
211 | while (!QTAILQ_EMPTY(&events_list)) { |
212 | Event *event = QTAILQ_FIRST(&events_list); | |
60618e2d | 213 | replay_save_event(event); |
c0c071d0 | 214 | replay_run_event(event); |
c0c071d0 PD |
215 | QTAILQ_REMOVE(&events_list, event, events); |
216 | g_free(event); | |
217 | } | |
218 | } | |
219 | ||
60618e2d | 220 | static Event *replay_read_event(void) |
c0c071d0 PD |
221 | { |
222 | Event *event; | |
3e21408b | 223 | ReplayAsyncEventKind event_kind = replay_state.data_kind - EVENT_ASYNC; |
c0c071d0 | 224 | |
c0c071d0 | 225 | /* Events that has not to be in the queue */ |
3e21408b | 226 | switch (event_kind) { |
8a354bd9 | 227 | case REPLAY_ASYNC_EVENT_BH: |
e4ec5ad4 | 228 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
0b30dc01 PD |
229 | if (replay_state.read_event_id == -1) { |
230 | replay_state.read_event_id = replay_get_qword(); | |
8a354bd9 PD |
231 | } |
232 | break; | |
ee312992 | 233 | case REPLAY_ASYNC_EVENT_INPUT: |
b21e2380 | 234 | event = g_new0(Event, 1); |
3e21408b | 235 | event->event_kind = event_kind; |
ee312992 PD |
236 | event->opaque = replay_read_input_event(); |
237 | return event; | |
238 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: | |
b21e2380 | 239 | event = g_new0(Event, 1); |
3e21408b | 240 | event->event_kind = event_kind; |
ee312992 PD |
241 | event->opaque = 0; |
242 | return event; | |
33577b47 | 243 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
b21e2380 | 244 | event = g_new0(Event, 1); |
3e21408b | 245 | event->event_kind = event_kind; |
33577b47 PD |
246 | event->opaque = replay_event_char_read_load(); |
247 | return event; | |
63785678 | 248 | case REPLAY_ASYNC_EVENT_BLOCK: |
0b30dc01 PD |
249 | if (replay_state.read_event_id == -1) { |
250 | replay_state.read_event_id = replay_get_qword(); | |
63785678 PD |
251 | } |
252 | break; | |
646c5478 | 253 | case REPLAY_ASYNC_EVENT_NET: |
b21e2380 | 254 | event = g_new0(Event, 1); |
3e21408b | 255 | event->event_kind = event_kind; |
646c5478 PD |
256 | event->opaque = replay_event_net_load(); |
257 | return event; | |
c0c071d0 | 258 | default: |
3e21408b | 259 | error_report("Unknown ID %d of replay event", event_kind); |
c0c071d0 PD |
260 | exit(1); |
261 | break; | |
262 | } | |
263 | ||
264 | QTAILQ_FOREACH(event, &events_list, events) { | |
3e21408b | 265 | if (event->event_kind == event_kind |
0b30dc01 PD |
266 | && (replay_state.read_event_id == -1 |
267 | || replay_state.read_event_id == event->id)) { | |
c0c071d0 PD |
268 | break; |
269 | } | |
270 | } | |
271 | ||
272 | if (event) { | |
273 | QTAILQ_REMOVE(&events_list, event, events); | |
c0c071d0 PD |
274 | } |
275 | ||
c0c071d0 PD |
276 | return event; |
277 | } | |
278 | ||
279 | /* Called with replay mutex locked */ | |
60618e2d | 280 | void replay_read_events(void) |
c0c071d0 | 281 | { |
d759c951 | 282 | g_assert(replay_mutex_locked()); |
3e21408b PD |
283 | while (replay_state.data_kind >= EVENT_ASYNC |
284 | && replay_state.data_kind <= EVENT_ASYNC_LAST) { | |
60618e2d | 285 | Event *event = replay_read_event(); |
c0c071d0 PD |
286 | if (!event) { |
287 | break; | |
288 | } | |
1a96e3c1 | 289 | replay_finish_event(); |
3e21408b | 290 | replay_state.read_event_id = -1; |
c0c071d0 | 291 | replay_run_event(event); |
c0c071d0 PD |
292 | |
293 | g_free(event); | |
c0c071d0 PD |
294 | } |
295 | } | |
296 | ||
297 | void replay_init_events(void) | |
298 | { | |
3e21408b | 299 | replay_state.read_event_id = -1; |
c0c071d0 PD |
300 | } |
301 | ||
302 | void replay_finish_events(void) | |
303 | { | |
304 | events_enabled = false; | |
d873fe03 | 305 | replay_flush_events(); |
c0c071d0 PD |
306 | } |
307 | ||
308 | bool replay_events_enabled(void) | |
309 | { | |
310 | return events_enabled; | |
311 | } | |
6d0ceb80 PD |
312 | |
313 | uint64_t blkreplay_next_id(void) | |
314 | { | |
315 | if (replay_events_enabled()) { | |
316 | return replay_state.block_request_id++; | |
317 | } | |
318 | return 0; | |
319 | } |