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