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