xref: /qemu/replay/replay-events.c (revision 28742467) 
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 }
330