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