sparc32-ledma: use object_initialize_child() for lance child object
[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 if (replay_mode == REPLAY_MODE_NONE) {
81 return;
82 }
83
84 g_assert(replay_mutex_locked());
85
86 while (!QTAILQ_EMPTY(&events_list)) {
87 Event *event = QTAILQ_FIRST(&events_list);
88 replay_run_event(event);
89 QTAILQ_REMOVE(&events_list, event, events);
90 g_free(event);
91 }
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
103 /*! Adds specified async event to the queue */
104 void replay_add_event(ReplayAsyncEventKind event_kind,
105 void *opaque,
106 void *opaque2, uint64_t id)
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
127 g_assert(replay_mutex_locked());
128 QTAILQ_INSERT_TAIL(&events_list, event, events);
129 }
130
131 void replay_bh_schedule_event(QEMUBH *bh)
132 {
133 if (events_enabled) {
134 uint64_t id = replay_get_current_icount();
135 replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
136 } else {
137 qemu_bh_schedule(bh);
138 }
139 }
140
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
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
162 void replay_block_event(QEMUBH *bh, uint64_t id)
163 {
164 if (events_enabled) {
165 replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
166 } else {
167 qemu_bh_schedule(bh);
168 }
169 }
170
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) {
181 case REPLAY_ASYNC_EVENT_BH:
182 case REPLAY_ASYNC_EVENT_BH_ONESHOT:
183 replay_put_qword(event->id);
184 break;
185 case REPLAY_ASYNC_EVENT_INPUT:
186 replay_save_input_event(event->opaque);
187 break;
188 case REPLAY_ASYNC_EVENT_INPUT_SYNC:
189 break;
190 case REPLAY_ASYNC_EVENT_CHAR_READ:
191 replay_event_char_read_save(event->opaque);
192 break;
193 case REPLAY_ASYNC_EVENT_BLOCK:
194 replay_put_qword(event->id);
195 break;
196 case REPLAY_ASYNC_EVENT_NET:
197 replay_event_net_save(event->opaque);
198 break;
199 default:
200 error_report("Unknown ID %" PRId64 " of replay event", event->id);
201 exit(1);
202 }
203 }
204 }
205
206 /* Called with replay mutex locked */
207 void replay_save_events(int checkpoint)
208 {
209 g_assert(replay_mutex_locked());
210 g_assert(checkpoint != CHECKPOINT_CLOCK_WARP_START);
211 g_assert(checkpoint != CHECKPOINT_CLOCK_VIRTUAL);
212 while (!QTAILQ_EMPTY(&events_list)) {
213 Event *event = QTAILQ_FIRST(&events_list);
214 replay_save_event(event, checkpoint);
215 replay_run_event(event);
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;
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;
228 replay_check_error();
229 }
230
231 if (checkpoint != replay_state.read_event_checkpoint) {
232 return NULL;
233 }
234
235 /* Events that has not to be in the queue */
236 switch (replay_state.read_event_kind) {
237 case REPLAY_ASYNC_EVENT_BH:
238 case REPLAY_ASYNC_EVENT_BH_ONESHOT:
239 if (replay_state.read_event_id == -1) {
240 replay_state.read_event_id = replay_get_qword();
241 }
242 break;
243 case REPLAY_ASYNC_EVENT_INPUT:
244 event = g_malloc0(sizeof(Event));
245 event->event_kind = replay_state.read_event_kind;
246 event->opaque = replay_read_input_event();
247 return event;
248 case REPLAY_ASYNC_EVENT_INPUT_SYNC:
249 event = g_malloc0(sizeof(Event));
250 event->event_kind = replay_state.read_event_kind;
251 event->opaque = 0;
252 return event;
253 case REPLAY_ASYNC_EVENT_CHAR_READ:
254 event = g_malloc0(sizeof(Event));
255 event->event_kind = replay_state.read_event_kind;
256 event->opaque = replay_event_char_read_load();
257 return event;
258 case REPLAY_ASYNC_EVENT_BLOCK:
259 if (replay_state.read_event_id == -1) {
260 replay_state.read_event_id = replay_get_qword();
261 }
262 break;
263 case REPLAY_ASYNC_EVENT_NET:
264 event = g_malloc0(sizeof(Event));
265 event->event_kind = replay_state.read_event_kind;
266 event->opaque = replay_event_net_load();
267 return event;
268 default:
269 error_report("Unknown ID %d of replay event",
270 replay_state.read_event_kind);
271 exit(1);
272 break;
273 }
274
275 QTAILQ_FOREACH(event, &events_list, events) {
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)) {
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 {
297 g_assert(replay_mutex_locked());
298 while (replay_state.data_kind == EVENT_ASYNC) {
299 Event *event = replay_read_event(checkpoint);
300 if (!event) {
301 break;
302 }
303 replay_finish_event();
304 replay_state.read_event_kind = -1;
305 replay_run_event(event);
306
307 g_free(event);
308 }
309 }
310
311 void replay_init_events(void)
312 {
313 replay_state.read_event_kind = -1;
314 }
315
316 void replay_finish_events(void)
317 {
318 events_enabled = false;
319 replay_flush_events();
320 }
321
322 bool replay_events_enabled(void)
323 {
324 return events_enabled;
325 }
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 }