@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 311 lines 7.89 KB
Raw
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 "system/replay.h"
15 #include "replay-internal.h"
16 #include "qemu/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, (QemuInputEvent *)event->opaque);
45 g_free(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 /*! Adds specified async event to the queue */
96 void replay_add_event(ReplayAsyncEventKind event_kind,
97 void *opaque,
98 void *opaque2, uint64_t id)
99 {
100 assert(event_kind < REPLAY_ASYNC_COUNT);
101
102 if (!replay_file || replay_mode == REPLAY_MODE_NONE
103 || !events_enabled) {
104 Event e;
105 e.event_kind = event_kind;
106 e.opaque = opaque;
107 e.opaque2 = opaque2;
108 e.id = id;
109 replay_run_event(&e);
110 return;
111 }
112
113 Event *event = g_new0(Event, 1);
114 event->event_kind = event_kind;
115 event->opaque = opaque;
116 event->opaque2 = opaque2;
117 event->id = id;
118
119 g_assert(replay_mutex_locked());
120 QTAILQ_INSERT_TAIL(&events_list, event, events);
121 /* Kick the TCG thread out of tcg_cpu_exec(). */
122 cpu_exit(first_cpu);
123 }
124
125 void replay_bh_schedule_event(QEMUBH *bh)
126 {
127 if (events_enabled) {
128 uint64_t id = replay_get_current_icount();
129 replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
130 } else {
131 qemu_bh_schedule(bh);
132 }
133 }
134
135 void replay_bh_schedule_oneshot_event(AioContext *ctx,
136 QEMUBHFunc *cb, void *opaque)
137 {
138 if (events_enabled) {
139 uint64_t id = replay_get_current_icount();
140 replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id);
141 } else {
142 aio_bh_schedule_oneshot(ctx, cb, opaque);
143 }
144 }
145
146 void replay_add_input_event(QemuInputEvent *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 void replay_block_event(QEMUBH *bh, uint64_t id)
157 {
158 if (events_enabled) {
159 replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
160 } else {
161 qemu_bh_schedule(bh);
162 }
163 }
164
165 static void replay_save_event(Event *event)
166 {
167 if (replay_mode != REPLAY_MODE_PLAY) {
168 /* put the event into the file */
169 g_assert(event->event_kind < REPLAY_ASYNC_COUNT);
170 replay_put_event(EVENT_ASYNC + event->event_kind);
171
172 /* save event-specific data */
173 switch (event->event_kind) {
174 case REPLAY_ASYNC_EVENT_BH:
175 case REPLAY_ASYNC_EVENT_BH_ONESHOT:
176 replay_put_qword(event->id);
177 break;
178 case REPLAY_ASYNC_EVENT_INPUT:
179 replay_save_input_event(event->opaque);
180 break;
181 case REPLAY_ASYNC_EVENT_INPUT_SYNC:
182 break;
183 case REPLAY_ASYNC_EVENT_CHAR_READ:
184 replay_event_char_read_save(event->opaque);
185 break;
186 case REPLAY_ASYNC_EVENT_BLOCK:
187 replay_put_qword(event->id);
188 break;
189 case REPLAY_ASYNC_EVENT_NET:
190 replay_event_net_save(event->opaque);
191 break;
192 default:
193 error_report("Unknown ID %" PRId64 " of replay event", event->id);
194 exit(1);
195 }
196 }
197 }
198
199 /* Called with replay mutex locked */
200 void replay_save_events(void)
201 {
202 g_assert(replay_mutex_locked());
203 while (!QTAILQ_EMPTY(&events_list)) {
204 Event *event = QTAILQ_FIRST(&events_list);
205 replay_save_event(event);
206 replay_run_event(event);
207 QTAILQ_REMOVE(&events_list, event, events);
208 g_free(event);
209 }
210 }
211
212 static Event *replay_read_event(void)
213 {
214 Event *event;
215 ReplayAsyncEventKind event_kind = replay_state.data_kind - EVENT_ASYNC;
216
217 /* Events that has not to be in the queue */
218 switch (event_kind) {
219 case REPLAY_ASYNC_EVENT_BH:
220 case REPLAY_ASYNC_EVENT_BH_ONESHOT:
221 if (replay_state.read_event_id == -1) {
222 replay_state.read_event_id = replay_get_qword();
223 }
224 break;
225 case REPLAY_ASYNC_EVENT_INPUT:
226 event = g_new0(Event, 1);
227 event->event_kind = event_kind;
228 event->opaque = replay_read_input_event();
229 return event;
230 case REPLAY_ASYNC_EVENT_INPUT_SYNC:
231 event = g_new0(Event, 1);
232 event->event_kind = event_kind;
233 event->opaque = 0;
234 return event;
235 case REPLAY_ASYNC_EVENT_CHAR_READ:
236 event = g_new0(Event, 1);
237 event->event_kind = event_kind;
238 event->opaque = replay_event_char_read_load();
239 return event;
240 case REPLAY_ASYNC_EVENT_BLOCK:
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_NET:
246 event = g_new0(Event, 1);
247 event->event_kind = event_kind;
248 event->opaque = replay_event_net_load();
249 return event;
250 default:
251 error_report("Unknown ID %d of replay event", event_kind);
252 exit(1);
253 break;
254 }
255
256 QTAILQ_FOREACH(event, &events_list, events) {
257 if (event->event_kind == event_kind
258 && (replay_state.read_event_id == -1
259 || replay_state.read_event_id == event->id)) {
260 break;
261 }
262 }
263
264 if (event) {
265 QTAILQ_REMOVE(&events_list, event, events);
266 }
267
268 return event;
269 }
270
271 /* Called with replay mutex locked */
272 void replay_read_events(void)
273 {
274 g_assert(replay_mutex_locked());
275 while (replay_state.data_kind >= EVENT_ASYNC
276 && replay_state.data_kind <= EVENT_ASYNC_LAST) {
277 Event *event = replay_read_event();
278 if (!event) {
279 break;
280 }
281 replay_finish_event();
282 replay_state.read_event_id = -1;
283 replay_run_event(event);
284
285 g_free(event);
286 }
287 }
288
289 void replay_init_events(void)
290 {
291 replay_state.read_event_id = -1;
292 }
293
294 void replay_finish_events(void)
295 {
296 events_enabled = false;
297 replay_flush_events();
298 }
299
300 bool replay_events_enabled(void)
301 {
302 return events_enabled;
303 }
304
305 uint64_t blkreplay_next_id(void)
306 {
307 if (replay_events_enabled()) {
308 return replay_state.block_request_id++;
309 }
310 return 0;
311 }