xref: /openbmc/qemu/replay/replay-events.c (revision d177892d) 
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 #include "hw/core/cpu.h"
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);
30 static bool events_enabled;
31 
32 /* Functions */
33 
34 static void replay_run_event(Event *event)
35 {
36     switch (event->event_kind) {
37     case REPLAY_ASYNC_EVENT_BH:
38         aio_bh_call(event->opaque);
39         break;
40     case REPLAY_ASYNC_EVENT_BH_ONESHOT:
41         ((QEMUBHFunc *)event->opaque)(event->opaque2);
42         break;
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;
50     case REPLAY_ASYNC_EVENT_CHAR_READ:
51         replay_event_char_read_run(event->opaque);
52         break;
53     case REPLAY_ASYNC_EVENT_BLOCK:
54         aio_bh_call(event->opaque);
55         break;
56     case REPLAY_ASYNC_EVENT_NET:
57         replay_event_net_run(event->opaque);
58         break;
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 {
69     if (replay_mode != REPLAY_MODE_NONE) {
70         events_enabled = true;
71     }
72 }
73 
74 bool replay_has_events(void)
75 {
76     return !QTAILQ_EMPTY(&events_list);
77 }
78 
79 void replay_flush_events(void)
80 {
81     if (replay_mode == REPLAY_MODE_NONE) {
82         return;
83     }
84 
85     g_assert(replay_mutex_locked());
86 
87     while (!QTAILQ_EMPTY(&events_list)) {
88         Event *event = QTAILQ_FIRST(&events_list);
89         replay_run_event(event);
90         QTAILQ_REMOVE(&events_list, event, events);
91         g_free(event);
92     }
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 
104 /*! Adds specified async event to the queue */
105 void replay_add_event(ReplayAsyncEventKind event_kind,
106                       void *opaque,
107                       void *opaque2, uint64_t id)
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 
128     g_assert(replay_mutex_locked());
129     QTAILQ_INSERT_TAIL(&events_list, event, events);
130     qemu_cpu_kick(first_cpu);
131 }
132 
133 void replay_bh_schedule_event(QEMUBH *bh)
134 {
135     if (events_enabled) {
136         uint64_t id = replay_get_current_icount();
137         replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
138     } else {
139         qemu_bh_schedule(bh);
140     }
141 }
142 
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 
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 
164 void replay_block_event(QEMUBH *bh, uint64_t id)
165 {
166     if (events_enabled) {
167         replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
168     } else {
169         qemu_bh_schedule(bh);
170     }
171 }
172 
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) {
183         case REPLAY_ASYNC_EVENT_BH:
184         case REPLAY_ASYNC_EVENT_BH_ONESHOT:
185             replay_put_qword(event->id);
186             break;
187         case REPLAY_ASYNC_EVENT_INPUT:
188             replay_save_input_event(event->opaque);
189             break;
190         case REPLAY_ASYNC_EVENT_INPUT_SYNC:
191             break;
192         case REPLAY_ASYNC_EVENT_CHAR_READ:
193             replay_event_char_read_save(event->opaque);
194             break;
195         case REPLAY_ASYNC_EVENT_BLOCK:
196             replay_put_qword(event->id);
197             break;
198         case REPLAY_ASYNC_EVENT_NET:
199             replay_event_net_save(event->opaque);
200             break;
201         default:
202             error_report("Unknown ID %" PRId64 " of replay event", event->id);
203             exit(1);
204         }
205     }
206 }
207 
208 /* Called with replay mutex locked */
209 void replay_save_events(int checkpoint)
210 {
211     g_assert(replay_mutex_locked());
212     g_assert(checkpoint != CHECKPOINT_CLOCK_WARP_START);
213     g_assert(checkpoint != CHECKPOINT_CLOCK_VIRTUAL);
214     while (!QTAILQ_EMPTY(&events_list)) {
215         Event *event = QTAILQ_FIRST(&events_list);
216         replay_save_event(event, checkpoint);
217         replay_run_event(event);
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;
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;
230         replay_check_error();
231     }
232 
233     if (checkpoint != replay_state.read_event_checkpoint) {
234         return NULL;
235     }
236 
237     /* Events that has not to be in the queue */
238     switch (replay_state.read_event_kind) {
239     case REPLAY_ASYNC_EVENT_BH:
240     case REPLAY_ASYNC_EVENT_BH_ONESHOT:
241         if (replay_state.read_event_id == -1) {
242             replay_state.read_event_id = replay_get_qword();
243         }
244         break;
245     case REPLAY_ASYNC_EVENT_INPUT:
246         event = g_malloc0(sizeof(Event));
247         event->event_kind = replay_state.read_event_kind;
248         event->opaque = replay_read_input_event();
249         return event;
250     case REPLAY_ASYNC_EVENT_INPUT_SYNC:
251         event = g_malloc0(sizeof(Event));
252         event->event_kind = replay_state.read_event_kind;
253         event->opaque = 0;
254         return event;
255     case REPLAY_ASYNC_EVENT_CHAR_READ:
256         event = g_malloc0(sizeof(Event));
257         event->event_kind = replay_state.read_event_kind;
258         event->opaque = replay_event_char_read_load();
259         return event;
260     case REPLAY_ASYNC_EVENT_BLOCK:
261         if (replay_state.read_event_id == -1) {
262             replay_state.read_event_id = replay_get_qword();
263         }
264         break;
265     case REPLAY_ASYNC_EVENT_NET:
266         event = g_malloc0(sizeof(Event));
267         event->event_kind = replay_state.read_event_kind;
268         event->opaque = replay_event_net_load();
269         return event;
270     default:
271         error_report("Unknown ID %d of replay event",
272             replay_state.read_event_kind);
273         exit(1);
274         break;
275     }
276 
277     QTAILQ_FOREACH(event, &events_list, events) {
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)) {
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 {
299     g_assert(replay_mutex_locked());
300     while (replay_state.data_kind == EVENT_ASYNC) {
301         Event *event = replay_read_event(checkpoint);
302         if (!event) {
303             break;
304         }
305         replay_finish_event();
306         replay_state.read_event_kind = -1;
307         replay_run_event(event);
308 
309         g_free(event);
310     }
311 }
312 
313 void replay_init_events(void)
314 {
315     replay_state.read_event_kind = -1;
316 }
317 
318 void replay_finish_events(void)
319 {
320     events_enabled = false;
321     replay_flush_events();
322 }
323 
324 bool replay_events_enabled(void)
325 {
326     return events_enabled;
327 }
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 }
336