Merge remote-tracking branch 'remotes/vivier2/tags/linux-user-for-6.2-pull-request...
[qemu.git] / replay / replay-events.c
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 }