1
2
3
4
5
6
7
8
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
19typedef 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
28static QTAILQ_HEAD(, Event) events_list = QTAILQ_HEAD_INITIALIZER(events_list);
29static bool events_enabled;
30
31
32
33static 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
63void replay_enable_events(void)
64{
65 if (replay_mode != REPLAY_MODE_NONE) {
66 events_enabled = true;
67 }
68}
69
70bool replay_has_events(void)
71{
72 return !QTAILQ_EMPTY(&events_list);
73}
74
75void 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
87void replay_disable_events(void)
88{
89 if (replay_mode != REPLAY_MODE_NONE) {
90 events_enabled = false;
91
92 replay_flush_events();
93 }
94}
95
96
97void 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
124void 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
134void replay_add_input_event(struct InputEvent *event)
135{
136 replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0);
137}
138
139void replay_add_input_sync_event(void)
140{
141 replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0);
142}
143
144void 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
153static void replay_save_event(Event *event, int checkpoint)
154{
155 if (replay_mode != REPLAY_MODE_PLAY) {
156
157 replay_put_event(EVENT_ASYNC);
158 replay_put_byte(checkpoint);
159 replay_put_byte(event->event_kind);
160
161
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
188void 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
202static 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
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
270
271 return event;
272}
273
274
275void 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
291void replay_init_events(void)
292{
293 replay_state.read_event_kind = -1;
294}
295
296void replay_finish_events(void)
297{
298 events_enabled = false;
299 replay_flush_events();
300}
301
302bool replay_events_enabled(void)
303{
304 return events_enabled;
305}
306
307uint64_t blkreplay_next_id(void)
308{
309 if (replay_events_enabled()) {
310 return replay_state.block_request_id++;
311 }
312 return 0;
313}
314
