4 * Copyright (c) 2010-2015 Institute for System Programming
5 * of the Russian Academy of Sciences.
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.
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"
20 typedef struct Event
{
21 ReplayAsyncEventKind event_kind
;
26 QTAILQ_ENTRY(Event
) events
;
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;
34 static bool events_enabled
;
38 static void replay_run_event(Event
*event
)
40 switch (event
->event_kind
) {
41 case REPLAY_ASYNC_EVENT_BH
:
42 aio_bh_call(event
->opaque
);
44 case REPLAY_ASYNC_EVENT_INPUT
:
45 qemu_input_event_send_impl(NULL
, (InputEvent
*)event
->opaque
);
46 qapi_free_InputEvent((InputEvent
*)event
->opaque
);
48 case REPLAY_ASYNC_EVENT_INPUT_SYNC
:
49 qemu_input_event_sync_impl();
51 case REPLAY_ASYNC_EVENT_CHAR_READ
:
52 replay_event_char_read_run(event
->opaque
);
54 case REPLAY_ASYNC_EVENT_BLOCK
:
55 aio_bh_call(event
->opaque
);
57 case REPLAY_ASYNC_EVENT_NET
:
58 replay_event_net_run(event
->opaque
);
61 error_report("Replay: invalid async event ID (%d) in the queue",
68 void replay_enable_events(void)
70 if (replay_mode
!= REPLAY_MODE_NONE
) {
71 events_enabled
= true;
75 bool replay_has_events(void)
77 return !QTAILQ_EMPTY(&events_list
);
80 void replay_flush_events(void)
82 g_assert(replay_mutex_locked());
84 while (!QTAILQ_EMPTY(&events_list
)) {
85 Event
*event
= QTAILQ_FIRST(&events_list
);
86 replay_run_event(event
);
87 QTAILQ_REMOVE(&events_list
, event
, events
);
92 void replay_disable_events(void)
94 if (replay_mode
!= REPLAY_MODE_NONE
) {
95 events_enabled
= false;
96 /* Flush events queue before waiting of completion */
97 replay_flush_events();
101 void replay_clear_events(void)
103 g_assert(replay_mutex_locked());
105 while (!QTAILQ_EMPTY(&events_list
)) {
106 Event
*event
= QTAILQ_FIRST(&events_list
);
107 QTAILQ_REMOVE(&events_list
, event
, events
);
113 /*! Adds specified async event to the queue */
114 void replay_add_event(ReplayAsyncEventKind event_kind
,
116 void *opaque2
, uint64_t id
)
118 assert(event_kind
< REPLAY_ASYNC_COUNT
);
120 if (!replay_file
|| replay_mode
== REPLAY_MODE_NONE
121 || !events_enabled
) {
123 e
.event_kind
= event_kind
;
127 replay_run_event(&e
);
131 Event
*event
= g_malloc0(sizeof(Event
));
132 event
->event_kind
= event_kind
;
133 event
->opaque
= opaque
;
134 event
->opaque2
= opaque2
;
137 g_assert(replay_mutex_locked());
138 QTAILQ_INSERT_TAIL(&events_list
, event
, events
);
141 void replay_bh_schedule_event(QEMUBH
*bh
)
143 if (events_enabled
) {
144 uint64_t id
= replay_get_current_step();
145 replay_add_event(REPLAY_ASYNC_EVENT_BH
, bh
, NULL
, id
);
147 qemu_bh_schedule(bh
);
151 void replay_add_input_event(struct InputEvent
*event
)
153 replay_add_event(REPLAY_ASYNC_EVENT_INPUT
, event
, NULL
, 0);
156 void replay_add_input_sync_event(void)
158 replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC
, NULL
, NULL
, 0);
161 void replay_block_event(QEMUBH
*bh
, uint64_t id
)
163 if (events_enabled
) {
164 replay_add_event(REPLAY_ASYNC_EVENT_BLOCK
, bh
, NULL
, id
);
166 qemu_bh_schedule(bh
);
170 static void replay_save_event(Event
*event
, int checkpoint
)
172 if (replay_mode
!= REPLAY_MODE_PLAY
) {
173 /* put the event into the file */
174 replay_put_event(EVENT_ASYNC
);
175 replay_put_byte(checkpoint
);
176 replay_put_byte(event
->event_kind
);
178 /* save event-specific data */
179 switch (event
->event_kind
) {
180 case REPLAY_ASYNC_EVENT_BH
:
181 replay_put_qword(event
->id
);
183 case REPLAY_ASYNC_EVENT_INPUT
:
184 replay_save_input_event(event
->opaque
);
186 case REPLAY_ASYNC_EVENT_INPUT_SYNC
:
188 case REPLAY_ASYNC_EVENT_CHAR_READ
:
189 replay_event_char_read_save(event
->opaque
);
191 case REPLAY_ASYNC_EVENT_BLOCK
:
192 replay_put_qword(event
->id
);
194 case REPLAY_ASYNC_EVENT_NET
:
195 replay_event_net_save(event
->opaque
);
198 error_report("Unknown ID %" PRId64
" of replay event", event
->id
);
204 /* Called with replay mutex locked */
205 void replay_save_events(int checkpoint
)
207 g_assert(replay_mutex_locked());
208 while (!QTAILQ_EMPTY(&events_list
)) {
209 Event
*event
= QTAILQ_FIRST(&events_list
);
210 replay_save_event(event
, checkpoint
);
211 replay_run_event(event
);
212 QTAILQ_REMOVE(&events_list
, event
, events
);
217 static Event
*replay_read_event(int checkpoint
)
220 if (read_event_kind
== -1) {
221 read_checkpoint
= replay_get_byte();
222 read_event_kind
= replay_get_byte();
224 replay_check_error();
227 if (checkpoint
!= read_checkpoint
) {
231 /* Events that has not to be in the queue */
232 switch (read_event_kind
) {
233 case REPLAY_ASYNC_EVENT_BH
:
235 read_id
= replay_get_qword();
238 case REPLAY_ASYNC_EVENT_INPUT
:
239 event
= g_malloc0(sizeof(Event
));
240 event
->event_kind
= read_event_kind
;
241 event
->opaque
= replay_read_input_event();
243 case REPLAY_ASYNC_EVENT_INPUT_SYNC
:
244 event
= g_malloc0(sizeof(Event
));
245 event
->event_kind
= read_event_kind
;
248 case REPLAY_ASYNC_EVENT_CHAR_READ
:
249 event
= g_malloc0(sizeof(Event
));
250 event
->event_kind
= read_event_kind
;
251 event
->opaque
= replay_event_char_read_load();
253 case REPLAY_ASYNC_EVENT_BLOCK
:
255 read_id
= replay_get_qword();
258 case REPLAY_ASYNC_EVENT_NET
:
259 event
= g_malloc0(sizeof(Event
));
260 event
->event_kind
= read_event_kind
;
261 event
->opaque
= replay_event_net_load();
264 error_report("Unknown ID %d of replay event", read_event_kind
);
269 QTAILQ_FOREACH(event
, &events_list
, events
) {
270 if (event
->event_kind
== read_event_kind
271 && (read_id
== -1 || read_id
== event
->id
)) {
277 QTAILQ_REMOVE(&events_list
, event
, events
);
282 /* Read event-specific data */
287 /* Called with replay mutex locked */
288 void replay_read_events(int checkpoint
)
290 g_assert(replay_mutex_locked());
291 while (replay_state
.data_kind
== EVENT_ASYNC
) {
292 Event
*event
= replay_read_event(checkpoint
);
296 replay_finish_event();
297 read_event_kind
= -1;
298 replay_run_event(event
);
304 void replay_init_events(void)
306 read_event_kind
= -1;
309 void replay_finish_events(void)
311 events_enabled
= false;
312 replay_clear_events();
315 bool replay_events_enabled(void)
317 return events_enabled
;
320 uint64_t blkreplay_next_id(void)
322 if (replay_events_enabled()) {
323 return replay_state
.block_request_id
++;