1 /*
2 * replay.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 "qapi/error.h"
14 #include "sysemu/cpu-timers.h"
15 #include "sysemu/replay.h"
16 #include "sysemu/runstate.h"
17 #include "replay-internal.h"
18 #include "qemu/main-loop.h"
19 #include "qemu/option.h"
20 #include "sysemu/cpus.h"
21 #include "qemu/error-report.h"
22
23 /* Current version of the replay mechanism.
24 Increase it when file format changes. */
25 #define REPLAY_VERSION 0xe0200c
26 /* Size of replay log header */
27 #define HEADER_SIZE (sizeof(uint32_t) + sizeof(uint64_t))
28
29 ReplayMode replay_mode = REPLAY_MODE_NONE;
30 char *replay_snapshot;
31
32 /* Name of replay file */
33 static char *replay_filename;
34 ReplayState replay_state;
35 static GSList *replay_blockers;
36
37 /* Replay breakpoints */
38 uint64_t replay_break_icount = -1ULL;
39 QEMUTimer *replay_break_timer;
40
41 /* Pretty print event names */
42
replay_async_event_name(ReplayAsyncEventKind event)43 static const char *replay_async_event_name(ReplayAsyncEventKind event)
44 {
45 switch (event) {
46 #define ASYNC_EVENT(_x) case REPLAY_ASYNC_EVENT_ ## _x: return "ASYNC_EVENT_"#_x
47 ASYNC_EVENT(BH);
48 ASYNC_EVENT(BH_ONESHOT);
49 ASYNC_EVENT(INPUT);
50 ASYNC_EVENT(INPUT_SYNC);
51 ASYNC_EVENT(CHAR_READ);
52 ASYNC_EVENT(BLOCK);
53 ASYNC_EVENT(NET);
54 #undef ASYNC_EVENT
55 default:
56 g_assert_not_reached();
57 }
58 }
59
replay_clock_event_name(ReplayClockKind clock)60 static const char *replay_clock_event_name(ReplayClockKind clock)
61 {
62 switch (clock) {
63 #define CLOCK_EVENT(_x) case REPLAY_CLOCK_ ## _x: return "CLOCK_" #_x
64 CLOCK_EVENT(HOST);
65 CLOCK_EVENT(VIRTUAL_RT);
66 #undef CLOCK_EVENT
67 default:
68 g_assert_not_reached();
69 }
70 }
71
72 /* Pretty print shutdown event names */
replay_shutdown_event_name(ShutdownCause cause)73 static const char *replay_shutdown_event_name(ShutdownCause cause)
74 {
75 switch (cause) {
76 #define SHUTDOWN_EVENT(_x) case SHUTDOWN_CAUSE_ ## _x: return "SHUTDOWN_CAUSE_" #_x
77 SHUTDOWN_EVENT(NONE);
78 SHUTDOWN_EVENT(HOST_ERROR);
79 SHUTDOWN_EVENT(HOST_QMP_QUIT);
80 SHUTDOWN_EVENT(HOST_QMP_SYSTEM_RESET);
81 SHUTDOWN_EVENT(HOST_SIGNAL);
82 SHUTDOWN_EVENT(HOST_UI);
83 SHUTDOWN_EVENT(GUEST_SHUTDOWN);
84 SHUTDOWN_EVENT(GUEST_RESET);
85 SHUTDOWN_EVENT(GUEST_PANIC);
86 SHUTDOWN_EVENT(SUBSYSTEM_RESET);
87 SHUTDOWN_EVENT(SNAPSHOT_LOAD);
88 #undef SHUTDOWN_EVENT
89 default:
90 g_assert_not_reached();
91 }
92 }
93
replay_checkpoint_event_name(enum ReplayCheckpoint checkpoint)94 static const char *replay_checkpoint_event_name(enum ReplayCheckpoint checkpoint)
95 {
96 switch (checkpoint) {
97 #define CHECKPOINT_EVENT(_x) case CHECKPOINT_ ## _x: return "CHECKPOINT_" #_x
98 CHECKPOINT_EVENT(CLOCK_WARP_START);
99 CHECKPOINT_EVENT(CLOCK_WARP_ACCOUNT);
100 CHECKPOINT_EVENT(RESET_REQUESTED);
101 CHECKPOINT_EVENT(SUSPEND_REQUESTED);
102 CHECKPOINT_EVENT(CLOCK_VIRTUAL);
103 CHECKPOINT_EVENT(CLOCK_HOST);
104 CHECKPOINT_EVENT(CLOCK_VIRTUAL_RT);
105 CHECKPOINT_EVENT(INIT);
106 CHECKPOINT_EVENT(RESET);
107 #undef CHECKPOINT_EVENT
108 default:
109 g_assert_not_reached();
110 }
111 }
112
replay_event_name(enum ReplayEvents event)113 static const char *replay_event_name(enum ReplayEvents event)
114 {
115 /* First deal with the simple ones */
116 switch (event) {
117 #define EVENT(_x) case EVENT_ ## _x: return "EVENT_"#_x
118 EVENT(INSTRUCTION);
119 EVENT(INTERRUPT);
120 EVENT(EXCEPTION);
121 EVENT(CHAR_WRITE);
122 EVENT(CHAR_READ_ALL);
123 EVENT(AUDIO_OUT);
124 EVENT(AUDIO_IN);
125 EVENT(RANDOM);
126 #undef EVENT
127 default:
128 if (event >= EVENT_ASYNC && event <= EVENT_ASYNC_LAST) {
129 return replay_async_event_name(event - EVENT_ASYNC);
130 } else if (event >= EVENT_SHUTDOWN && event <= EVENT_SHUTDOWN_LAST) {
131 return replay_shutdown_event_name(event - EVENT_SHUTDOWN);
132 } else if (event >= EVENT_CLOCK && event <= EVENT_CLOCK_LAST) {
133 return replay_clock_event_name(event - EVENT_CLOCK);
134 } else if (event >= EVENT_CHECKPOINT && event <= EVENT_CHECKPOINT_LAST) {
135 return replay_checkpoint_event_name(event - EVENT_CHECKPOINT);
136 }
137 }
138
139 g_assert_not_reached();
140 }
141
replay_next_event_is(int event)142 bool replay_next_event_is(int event)
143 {
144 bool res = false;
145
146 /* nothing to skip - not all instructions used */
147 if (replay_state.instruction_count != 0) {
148 assert(replay_state.data_kind == EVENT_INSTRUCTION);
149 return event == EVENT_INSTRUCTION;
150 }
151
152 while (true) {
153 unsigned int data_kind = replay_state.data_kind;
154 if (event == data_kind) {
155 res = true;
156 }
157 switch (data_kind) {
158 case EVENT_SHUTDOWN ... EVENT_SHUTDOWN_LAST:
159 replay_finish_event();
160 qemu_system_shutdown_request(data_kind - EVENT_SHUTDOWN);
161 break;
162 default:
163 /* clock, time_t, checkpoint and other events */
164 return res;
165 }
166 }
167 return res;
168 }
169
replay_get_current_icount(void)170 uint64_t replay_get_current_icount(void)
171 {
172 return icount_get_raw();
173 }
174
replay_get_instructions(void)175 int replay_get_instructions(void)
176 {
177 int res = 0;
178 g_assert(replay_mutex_locked());
179 if (replay_next_event_is(EVENT_INSTRUCTION)) {
180 res = replay_state.instruction_count;
181 if (replay_break_icount != -1LL) {
182 uint64_t current = replay_get_current_icount();
183 assert(replay_break_icount >= current);
184 if (current + res > replay_break_icount) {
185 res = replay_break_icount - current;
186 }
187 }
188 }
189 return res;
190 }
191
replay_account_executed_instructions(void)192 void replay_account_executed_instructions(void)
193 {
194 if (replay_mode == REPLAY_MODE_PLAY) {
195 g_assert(replay_mutex_locked());
196 if (replay_state.instruction_count > 0) {
197 replay_advance_current_icount(replay_get_current_icount());
198 }
199 }
200 }
201
replay_exception(void)202 bool replay_exception(void)
203 {
204
205 if (replay_mode == REPLAY_MODE_RECORD) {
206 g_assert(replay_mutex_locked());
207 replay_save_instructions();
208 replay_put_event(EVENT_EXCEPTION);
209 return true;
210 } else if (replay_mode == REPLAY_MODE_PLAY) {
211 g_assert(replay_mutex_locked());
212 bool res = replay_has_exception();
213 if (res) {
214 replay_finish_event();
215 }
216 return res;
217 }
218
219 return true;
220 }
221
replay_has_exception(void)222 bool replay_has_exception(void)
223 {
224 bool res = false;
225 if (replay_mode == REPLAY_MODE_PLAY) {
226 g_assert(replay_mutex_locked());
227 replay_account_executed_instructions();
228 res = replay_next_event_is(EVENT_EXCEPTION);
229 }
230
231 return res;
232 }
233
replay_interrupt(void)234 bool replay_interrupt(void)
235 {
236 if (replay_mode == REPLAY_MODE_RECORD) {
237 g_assert(replay_mutex_locked());
238 replay_save_instructions();
239 replay_put_event(EVENT_INTERRUPT);
240 return true;
241 } else if (replay_mode == REPLAY_MODE_PLAY) {
242 g_assert(replay_mutex_locked());
243 bool res = replay_has_interrupt();
244 if (res) {
245 replay_finish_event();
246 }
247 return res;
248 }
249
250 return true;
251 }
252
replay_has_interrupt(void)253 bool replay_has_interrupt(void)
254 {
255 bool res = false;
256 if (replay_mode == REPLAY_MODE_PLAY) {
257 g_assert(replay_mutex_locked());
258 replay_account_executed_instructions();
259 res = replay_next_event_is(EVENT_INTERRUPT);
260 }
261 return res;
262 }
263
replay_shutdown_request(ShutdownCause cause)264 void replay_shutdown_request(ShutdownCause cause)
265 {
266 if (replay_mode == REPLAY_MODE_RECORD) {
267 g_assert(replay_mutex_locked());
268 replay_put_event(EVENT_SHUTDOWN + cause);
269 }
270 }
271
replay_checkpoint(ReplayCheckpoint checkpoint)272 bool replay_checkpoint(ReplayCheckpoint checkpoint)
273 {
274 assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);
275
276 replay_save_instructions();
277
278 if (replay_mode == REPLAY_MODE_PLAY) {
279 g_assert(replay_mutex_locked());
280 if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
281 replay_finish_event();
282 } else {
283 return false;
284 }
285 } else if (replay_mode == REPLAY_MODE_RECORD) {
286 g_assert(replay_mutex_locked());
287 replay_put_event(EVENT_CHECKPOINT + checkpoint);
288 }
289 return true;
290 }
291
replay_async_events(void)292 void replay_async_events(void)
293 {
294 static bool processing = false;
295 /*
296 * If we are already processing the events, recursion may occur
297 * in case of incorrect implementation when HW event modifies timers.
298 * Timer modification may invoke the icount warp, event processing,
299 * and cause the recursion.
300 */
301 g_assert(!processing);
302 processing = true;
303
304 replay_save_instructions();
305
306 if (replay_mode == REPLAY_MODE_PLAY) {
307 g_assert(replay_mutex_locked());
308 replay_read_events();
309 } else if (replay_mode == REPLAY_MODE_RECORD) {
310 g_assert(replay_mutex_locked());
311 replay_save_events();
312 }
313 processing = false;
314 }
315
replay_has_event(void)316 bool replay_has_event(void)
317 {
318 bool res = false;
319 if (replay_mode == REPLAY_MODE_PLAY) {
320 g_assert(replay_mutex_locked());
321 replay_account_executed_instructions();
322 res = EVENT_CHECKPOINT <= replay_state.data_kind
323 && replay_state.data_kind <= EVENT_CHECKPOINT_LAST;
324 res = res || (EVENT_ASYNC <= replay_state.data_kind
325 && replay_state.data_kind <= EVENT_ASYNC_LAST);
326 }
327 return res;
328 }
329
replay_sync_error(const char * error)330 G_NORETURN void replay_sync_error(const char *error)
331 {
332 error_report("%s (insn total %"PRId64"/%d left, event %d is %s)", error,
333 replay_state.current_icount, replay_state.instruction_count,
334 replay_state.current_event,
335 replay_event_name(replay_state.data_kind));
336 abort();
337 }
338
replay_enable(const char * fname,int mode)339 static void replay_enable(const char *fname, int mode)
340 {
341 const char *fmode = NULL;
342 assert(!replay_file);
343
344 switch (mode) {
345 case REPLAY_MODE_RECORD:
346 fmode = "wb";
347 break;
348 case REPLAY_MODE_PLAY:
349 fmode = "rb";
350 break;
351 default:
352 fprintf(stderr, "Replay: internal error: invalid replay mode\n");
353 exit(1);
354 }
355
356 atexit(replay_finish);
357
358 replay_file = fopen(fname, fmode);
359 if (replay_file == NULL) {
360 fprintf(stderr, "Replay: open %s: %s\n", fname, strerror(errno));
361 exit(1);
362 }
363
364 replay_filename = g_strdup(fname);
365 replay_mode = mode;
366 replay_mutex_init();
367
368 replay_state.data_kind = -1;
369 replay_state.instruction_count = 0;
370 replay_state.current_icount = 0;
371 replay_state.current_event = 0;
372 replay_state.has_unread_data = 0;
373
374 /* skip file header for RECORD and check it for PLAY */
375 if (replay_mode == REPLAY_MODE_RECORD) {
376 fseek(replay_file, HEADER_SIZE, SEEK_SET);
377 } else if (replay_mode == REPLAY_MODE_PLAY) {
378 unsigned int version = replay_get_dword();
379 if (version != REPLAY_VERSION) {
380 fprintf(stderr, "Replay: invalid input log file version\n");
381 exit(1);
382 }
383 /* go to the beginning */
384 fseek(replay_file, HEADER_SIZE, SEEK_SET);
385 replay_fetch_data_kind();
386 }
387
388 runstate_replay_enable();
389
390 replay_init_events();
391 }
392
replay_configure(QemuOpts * opts)393 void replay_configure(QemuOpts *opts)
394 {
395 const char *fname;
396 const char *rr;
397 ReplayMode mode = REPLAY_MODE_NONE;
398 Location loc;
399
400 if (!opts) {
401 return;
402 }
403
404 loc_push_none(&loc);
405 qemu_opts_loc_restore(opts);
406
407 rr = qemu_opt_get(opts, "rr");
408 if (!rr) {
409 /* Just enabling icount */
410 goto out;
411 } else if (!strcmp(rr, "record")) {
412 mode = REPLAY_MODE_RECORD;
413 } else if (!strcmp(rr, "replay")) {
414 mode = REPLAY_MODE_PLAY;
415 } else {
416 error_report("Invalid icount rr option: %s", rr);
417 exit(1);
418 }
419
420 fname = qemu_opt_get(opts, "rrfile");
421 if (!fname) {
422 error_report("File name not specified for replay");
423 exit(1);
424 }
425
426 replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot"));
427 replay_vmstate_register();
428 replay_enable(fname, mode);
429
430 out:
431 loc_pop(&loc);
432 }
433
replay_start(void)434 void replay_start(void)
435 {
436 if (replay_mode == REPLAY_MODE_NONE) {
437 return;
438 }
439
440 if (replay_blockers) {
441 error_reportf_err(replay_blockers->data, "Record/replay: ");
442 exit(1);
443 }
444 if (!icount_enabled()) {
445 error_report("Please enable icount to use record/replay");
446 exit(1);
447 }
448
449 /* Timer for snapshotting will be set up here. */
450
451 replay_enable_events();
452 }
453
replay_finish(void)454 void replay_finish(void)
455 {
456 if (replay_mode == REPLAY_MODE_NONE) {
457 return;
458 }
459
460 replay_save_instructions();
461
462 /* finalize the file */
463 if (replay_file) {
464 if (replay_mode == REPLAY_MODE_RECORD) {
465 /*
466 * Can't do it in the signal handler, therefore
467 * add shutdown event here for the case of Ctrl-C.
468 */
469 replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL);
470 /* write end event */
471 replay_put_event(EVENT_END);
472
473 /* write header */
474 fseek(replay_file, 0, SEEK_SET);
475 replay_put_dword(REPLAY_VERSION);
476 }
477
478 fclose(replay_file);
479 replay_file = NULL;
480 }
481 g_free(replay_filename);
482 replay_filename = NULL;
483
484 g_free(replay_snapshot);
485 replay_snapshot = NULL;
486
487 replay_finish_events();
488 replay_mode = REPLAY_MODE_NONE;
489 }
490
replay_add_blocker(const char * feature)491 void replay_add_blocker(const char *feature)
492 {
493 Error *reason = NULL;
494
495 error_setg(&reason, "Record/replay is not supported with %s",
496 feature);
497 replay_blockers = g_slist_prepend(replay_blockers, reason);
498 }
499
replay_get_filename(void)500 const char *replay_get_filename(void)
501 {
502 return replay_filename;
503 }
504