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