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 "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"
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))
29 ReplayMode replay_mode
= REPLAY_MODE_NONE
;
30 char *replay_snapshot
;
32 /* Name of replay file */
33 static char *replay_filename
;
34 ReplayState replay_state
;
35 static GSList
*replay_blockers
;
37 /* Replay breakpoints */
38 uint64_t replay_break_icount
= -1ULL;
39 QEMUTimer
*replay_break_timer
;
41 bool replay_next_event_is(int event
)
45 /* nothing to skip - not all instructions used */
46 if (replay_state
.instruction_count
!= 0) {
47 assert(replay_state
.data_kind
== EVENT_INSTRUCTION
);
48 return event
== EVENT_INSTRUCTION
;
52 unsigned int data_kind
= replay_state
.data_kind
;
53 if (event
== data_kind
) {
57 case EVENT_SHUTDOWN
... EVENT_SHUTDOWN_LAST
:
58 replay_finish_event();
59 qemu_system_shutdown_request(data_kind
- EVENT_SHUTDOWN
);
62 /* clock, time_t, checkpoint and other events */
69 uint64_t replay_get_current_icount(void)
71 return icount_get_raw();
74 int replay_get_instructions(void)
78 if (replay_next_event_is(EVENT_INSTRUCTION
)) {
79 res
= replay_state
.instruction_count
;
80 if (replay_break_icount
!= -1LL) {
81 uint64_t current
= replay_get_current_icount();
82 assert(replay_break_icount
>= current
);
83 if (current
+ res
> replay_break_icount
) {
84 res
= replay_break_icount
- current
;
88 replay_mutex_unlock();
92 void replay_account_executed_instructions(void)
94 if (replay_mode
== REPLAY_MODE_PLAY
) {
95 g_assert(replay_mutex_locked());
96 if (replay_state
.instruction_count
> 0) {
97 replay_advance_current_icount(replay_get_current_icount());
102 bool replay_exception(void)
105 if (replay_mode
== REPLAY_MODE_RECORD
) {
106 g_assert(replay_mutex_locked());
107 replay_save_instructions();
108 replay_put_event(EVENT_EXCEPTION
);
110 } else if (replay_mode
== REPLAY_MODE_PLAY
) {
111 g_assert(replay_mutex_locked());
112 bool res
= replay_has_exception();
114 replay_finish_event();
122 bool replay_has_exception(void)
125 if (replay_mode
== REPLAY_MODE_PLAY
) {
126 g_assert(replay_mutex_locked());
127 replay_account_executed_instructions();
128 res
= replay_next_event_is(EVENT_EXCEPTION
);
134 bool replay_interrupt(void)
136 if (replay_mode
== REPLAY_MODE_RECORD
) {
137 g_assert(replay_mutex_locked());
138 replay_save_instructions();
139 replay_put_event(EVENT_INTERRUPT
);
141 } else if (replay_mode
== REPLAY_MODE_PLAY
) {
142 g_assert(replay_mutex_locked());
143 bool res
= replay_has_interrupt();
145 replay_finish_event();
153 bool replay_has_interrupt(void)
156 if (replay_mode
== REPLAY_MODE_PLAY
) {
157 g_assert(replay_mutex_locked());
158 replay_account_executed_instructions();
159 res
= replay_next_event_is(EVENT_INTERRUPT
);
164 void replay_shutdown_request(ShutdownCause cause
)
166 if (replay_mode
== REPLAY_MODE_RECORD
) {
167 g_assert(replay_mutex_locked());
168 replay_put_event(EVENT_SHUTDOWN
+ cause
);
172 bool replay_checkpoint(ReplayCheckpoint checkpoint
)
174 assert(EVENT_CHECKPOINT
+ checkpoint
<= EVENT_CHECKPOINT_LAST
);
176 replay_save_instructions();
178 if (replay_mode
== REPLAY_MODE_PLAY
) {
179 g_assert(replay_mutex_locked());
180 if (replay_next_event_is(EVENT_CHECKPOINT
+ checkpoint
)) {
181 replay_finish_event();
185 } else if (replay_mode
== REPLAY_MODE_RECORD
) {
186 g_assert(replay_mutex_locked());
187 replay_put_event(EVENT_CHECKPOINT
+ checkpoint
);
192 void replay_async_events(void)
194 static bool processing
= false;
196 * If we are already processing the events, recursion may occur
197 * in case of incorrect implementation when HW event modifies timers.
198 * Timer modification may invoke the icount warp, event processing,
199 * and cause the recursion.
201 g_assert(!processing
);
204 replay_save_instructions();
206 if (replay_mode
== REPLAY_MODE_PLAY
) {
207 g_assert(replay_mutex_locked());
208 replay_read_events();
209 } else if (replay_mode
== REPLAY_MODE_RECORD
) {
210 g_assert(replay_mutex_locked());
211 replay_save_events();
216 bool replay_has_event(void)
219 if (replay_mode
== REPLAY_MODE_PLAY
) {
220 g_assert(replay_mutex_locked());
221 replay_account_executed_instructions();
222 res
= EVENT_CHECKPOINT
<= replay_state
.data_kind
223 && replay_state
.data_kind
<= EVENT_CHECKPOINT_LAST
;
224 res
= res
|| (EVENT_ASYNC
<= replay_state
.data_kind
225 && replay_state
.data_kind
<= EVENT_ASYNC_LAST
);
230 static void replay_enable(const char *fname
, int mode
)
232 const char *fmode
= NULL
;
233 assert(!replay_file
);
236 case REPLAY_MODE_RECORD
:
239 case REPLAY_MODE_PLAY
:
243 fprintf(stderr
, "Replay: internal error: invalid replay mode\n");
247 atexit(replay_finish
);
249 replay_file
= fopen(fname
, fmode
);
250 if (replay_file
== NULL
) {
251 fprintf(stderr
, "Replay: open %s: %s\n", fname
, strerror(errno
));
255 replay_filename
= g_strdup(fname
);
259 replay_state
.data_kind
= -1;
260 replay_state
.instruction_count
= 0;
261 replay_state
.current_icount
= 0;
262 replay_state
.has_unread_data
= 0;
264 /* skip file header for RECORD and check it for PLAY */
265 if (replay_mode
== REPLAY_MODE_RECORD
) {
266 fseek(replay_file
, HEADER_SIZE
, SEEK_SET
);
267 } else if (replay_mode
== REPLAY_MODE_PLAY
) {
268 unsigned int version
= replay_get_dword();
269 if (version
!= REPLAY_VERSION
) {
270 fprintf(stderr
, "Replay: invalid input log file version\n");
273 /* go to the beginning */
274 fseek(replay_file
, HEADER_SIZE
, SEEK_SET
);
275 replay_fetch_data_kind();
278 replay_init_events();
281 void replay_configure(QemuOpts
*opts
)
285 ReplayMode mode
= REPLAY_MODE_NONE
;
293 qemu_opts_loc_restore(opts
);
295 rr
= qemu_opt_get(opts
, "rr");
297 /* Just enabling icount */
299 } else if (!strcmp(rr
, "record")) {
300 mode
= REPLAY_MODE_RECORD
;
301 } else if (!strcmp(rr
, "replay")) {
302 mode
= REPLAY_MODE_PLAY
;
304 error_report("Invalid icount rr option: %s", rr
);
308 fname
= qemu_opt_get(opts
, "rrfile");
310 error_report("File name not specified for replay");
314 replay_snapshot
= g_strdup(qemu_opt_get(opts
, "rrsnapshot"));
315 replay_vmstate_register();
316 replay_enable(fname
, mode
);
322 void replay_start(void)
324 if (replay_mode
== REPLAY_MODE_NONE
) {
328 if (replay_blockers
) {
329 error_reportf_err(replay_blockers
->data
, "Record/replay: ");
332 if (!icount_enabled()) {
333 error_report("Please enable icount to use record/replay");
337 /* Timer for snapshotting will be set up here. */
339 replay_enable_events();
342 void replay_finish(void)
344 if (replay_mode
== REPLAY_MODE_NONE
) {
348 replay_save_instructions();
350 /* finalize the file */
352 if (replay_mode
== REPLAY_MODE_RECORD
) {
354 * Can't do it in the signal handler, therefore
355 * add shutdown event here for the case of Ctrl-C.
357 replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL
);
358 /* write end event */
359 replay_put_event(EVENT_END
);
362 fseek(replay_file
, 0, SEEK_SET
);
363 replay_put_dword(REPLAY_VERSION
);
369 g_free(replay_filename
);
370 replay_filename
= NULL
;
372 g_free(replay_snapshot
);
373 replay_snapshot
= NULL
;
375 replay_finish_events();
376 replay_mode
= REPLAY_MODE_NONE
;
379 void replay_add_blocker(const char *feature
)
381 Error
*reason
= NULL
;
383 error_setg(&reason
, "Record/replay feature is not supported for '%s'",
385 replay_blockers
= g_slist_prepend(replay_blockers
, reason
);
388 const char *replay_get_filename(void)
390 return replay_filename
;