2015-09-17 18:23:37 +02:00
|
|
|
/*
|
|
|
|
* replay.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2010-2015 Institute for System Programming
|
|
|
|
* of the Russian Academy of Sciences.
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-01-29 18:50:05 +01:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2020-08-19 13:17:19 +02:00
|
|
|
#include "sysemu/cpu-timers.h"
|
2015-09-17 18:23:37 +02:00
|
|
|
#include "sysemu/replay.h"
|
2019-08-12 07:23:59 +02:00
|
|
|
#include "sysemu/runstate.h"
|
2015-09-17 18:23:54 +02:00
|
|
|
#include "replay-internal.h"
|
2015-09-17 18:24:05 +02:00
|
|
|
#include "qemu/main-loop.h"
|
2018-02-01 12:18:46 +01:00
|
|
|
#include "qemu/option.h"
|
2017-03-03 12:01:16 +01:00
|
|
|
#include "sysemu/cpus.h"
|
2015-09-17 18:25:07 +02:00
|
|
|
#include "qemu/error-report.h"
|
|
|
|
|
|
|
|
/* Current version of the replay mechanism.
|
|
|
|
Increase it when file format changes. */
|
2020-05-22 08:35:27 +02:00
|
|
|
#define REPLAY_VERSION 0xe0200a
|
2015-09-17 18:25:07 +02:00
|
|
|
/* Size of replay log header */
|
|
|
|
#define HEADER_SIZE (sizeof(uint32_t) + sizeof(uint64_t))
|
2015-09-17 18:23:37 +02:00
|
|
|
|
|
|
|
ReplayMode replay_mode = REPLAY_MODE_NONE;
|
2017-01-24 08:17:47 +01:00
|
|
|
char *replay_snapshot;
|
2015-09-17 18:23:54 +02:00
|
|
|
|
2015-09-17 18:25:07 +02:00
|
|
|
/* Name of replay file */
|
|
|
|
static char *replay_filename;
|
2015-09-17 18:23:54 +02:00
|
|
|
ReplayState replay_state;
|
2015-09-17 18:25:13 +02:00
|
|
|
static GSList *replay_blockers;
|
2015-09-17 18:23:54 +02:00
|
|
|
|
|
|
|
bool replay_next_event_is(int event)
|
|
|
|
{
|
|
|
|
bool res = false;
|
|
|
|
|
|
|
|
/* nothing to skip - not all instructions used */
|
2019-07-25 10:44:43 +02:00
|
|
|
if (replay_state.instruction_count != 0) {
|
2016-09-26 10:08:04 +02:00
|
|
|
assert(replay_state.data_kind == EVENT_INSTRUCTION);
|
2015-09-17 18:23:54 +02:00
|
|
|
return event == EVENT_INSTRUCTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (true) {
|
2019-07-25 10:44:32 +02:00
|
|
|
unsigned int data_kind = replay_state.data_kind;
|
|
|
|
if (event == data_kind) {
|
2015-09-17 18:23:54 +02:00
|
|
|
res = true;
|
|
|
|
}
|
2019-07-25 10:44:32 +02:00
|
|
|
switch (data_kind) {
|
2017-05-15 23:41:12 +02:00
|
|
|
case EVENT_SHUTDOWN ... EVENT_SHUTDOWN_LAST:
|
2015-09-17 18:24:33 +02:00
|
|
|
replay_finish_event();
|
2019-07-25 10:44:32 +02:00
|
|
|
qemu_system_shutdown_request(data_kind - EVENT_SHUTDOWN);
|
2015-09-17 18:24:33 +02:00
|
|
|
break;
|
2015-09-17 18:23:54 +02:00
|
|
|
default:
|
|
|
|
/* clock, time_t, checkpoint and other events */
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2019-07-25 10:44:43 +02:00
|
|
|
uint64_t replay_get_current_icount(void)
|
2015-09-17 18:23:54 +02:00
|
|
|
{
|
|
|
|
return cpu_get_icount_raw();
|
|
|
|
}
|
2015-09-17 18:24:05 +02:00
|
|
|
|
|
|
|
int replay_get_instructions(void)
|
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
replay_mutex_lock();
|
|
|
|
if (replay_next_event_is(EVENT_INSTRUCTION)) {
|
2019-07-25 10:44:43 +02:00
|
|
|
res = replay_state.instruction_count;
|
2015-09-17 18:24:05 +02:00
|
|
|
}
|
|
|
|
replay_mutex_unlock();
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void replay_account_executed_instructions(void)
|
|
|
|
{
|
|
|
|
if (replay_mode == REPLAY_MODE_PLAY) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2019-07-25 10:44:43 +02:00
|
|
|
if (replay_state.instruction_count > 0) {
|
|
|
|
int count = (int)(replay_get_current_icount()
|
|
|
|
- replay_state.current_icount);
|
2017-04-05 12:05:28 +02:00
|
|
|
|
|
|
|
/* Time can only go forward */
|
|
|
|
assert(count >= 0);
|
|
|
|
|
2019-07-25 10:44:43 +02:00
|
|
|
replay_state.instruction_count -= count;
|
|
|
|
replay_state.current_icount += count;
|
|
|
|
if (replay_state.instruction_count == 0) {
|
2016-09-26 10:08:04 +02:00
|
|
|
assert(replay_state.data_kind == EVENT_INSTRUCTION);
|
2015-09-17 18:24:05 +02:00
|
|
|
replay_finish_event();
|
|
|
|
/* Wake up iothread. This is required because
|
|
|
|
timers will not expire until clock counters
|
|
|
|
will be read from the log. */
|
|
|
|
qemu_notify_event();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-09-17 18:24:16 +02:00
|
|
|
|
|
|
|
bool replay_exception(void)
|
|
|
|
{
|
2018-02-27 10:52:48 +01:00
|
|
|
|
2015-09-17 18:24:16 +02:00
|
|
|
if (replay_mode == REPLAY_MODE_RECORD) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:16 +02:00
|
|
|
replay_save_instructions();
|
|
|
|
replay_put_event(EVENT_EXCEPTION);
|
|
|
|
return true;
|
|
|
|
} else if (replay_mode == REPLAY_MODE_PLAY) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:16 +02:00
|
|
|
bool res = replay_has_exception();
|
|
|
|
if (res) {
|
|
|
|
replay_finish_event();
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool replay_has_exception(void)
|
|
|
|
{
|
|
|
|
bool res = false;
|
|
|
|
if (replay_mode == REPLAY_MODE_PLAY) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:16 +02:00
|
|
|
replay_account_executed_instructions();
|
|
|
|
res = replay_next_event_is(EVENT_EXCEPTION);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool replay_interrupt(void)
|
|
|
|
{
|
|
|
|
if (replay_mode == REPLAY_MODE_RECORD) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:16 +02:00
|
|
|
replay_save_instructions();
|
|
|
|
replay_put_event(EVENT_INTERRUPT);
|
|
|
|
return true;
|
|
|
|
} else if (replay_mode == REPLAY_MODE_PLAY) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:16 +02:00
|
|
|
bool res = replay_has_interrupt();
|
|
|
|
if (res) {
|
|
|
|
replay_finish_event();
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool replay_has_interrupt(void)
|
|
|
|
{
|
|
|
|
bool res = false;
|
|
|
|
if (replay_mode == REPLAY_MODE_PLAY) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:16 +02:00
|
|
|
replay_account_executed_instructions();
|
|
|
|
res = replay_next_event_is(EVENT_INTERRUPT);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
2015-09-17 18:24:33 +02:00
|
|
|
|
2017-05-15 23:41:12 +02:00
|
|
|
void replay_shutdown_request(ShutdownCause cause)
|
2015-09-17 18:24:33 +02:00
|
|
|
{
|
|
|
|
if (replay_mode == REPLAY_MODE_RECORD) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2017-05-15 23:41:12 +02:00
|
|
|
replay_put_event(EVENT_SHUTDOWN + cause);
|
2015-09-17 18:24:33 +02:00
|
|
|
}
|
|
|
|
}
|
2015-09-17 18:24:44 +02:00
|
|
|
|
|
|
|
bool replay_checkpoint(ReplayCheckpoint checkpoint)
|
|
|
|
{
|
|
|
|
bool res = false;
|
2018-02-27 10:53:05 +01:00
|
|
|
static bool in_checkpoint;
|
2015-09-17 18:24:44 +02:00
|
|
|
assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);
|
|
|
|
|
|
|
|
if (!replay_file) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-02-27 10:53:05 +01:00
|
|
|
if (in_checkpoint) {
|
|
|
|
/* If we are already in checkpoint, then there is no need
|
|
|
|
for additional synchronization.
|
|
|
|
Recursion occurs when HW event modifies timers.
|
|
|
|
Timer modification may invoke the checkpoint and
|
|
|
|
proceed to recursion. */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
in_checkpoint = true;
|
|
|
|
|
|
|
|
replay_save_instructions();
|
2015-09-17 18:24:44 +02:00
|
|
|
|
|
|
|
if (replay_mode == REPLAY_MODE_PLAY) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:44 +02:00
|
|
|
if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
|
|
|
|
replay_finish_event();
|
2016-09-26 10:08:04 +02:00
|
|
|
} else if (replay_state.data_kind != EVENT_ASYNC) {
|
2015-09-17 18:24:44 +02:00
|
|
|
res = false;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
replay_read_events(checkpoint);
|
|
|
|
/* replay_read_events may leave some unread events.
|
|
|
|
Return false if not all of the events associated with
|
|
|
|
checkpoint were processed */
|
2016-09-26 10:08:04 +02:00
|
|
|
res = replay_state.data_kind != EVENT_ASYNC;
|
2015-09-17 18:24:44 +02:00
|
|
|
} else if (replay_mode == REPLAY_MODE_RECORD) {
|
2018-02-27 10:52:48 +01:00
|
|
|
g_assert(replay_mutex_locked());
|
2015-09-17 18:24:44 +02:00
|
|
|
replay_put_event(EVENT_CHECKPOINT + checkpoint);
|
2018-02-27 10:53:16 +01:00
|
|
|
/* This checkpoint belongs to several threads.
|
|
|
|
Processing events from different threads is
|
|
|
|
non-deterministic */
|
2018-10-18 08:33:45 +02:00
|
|
|
if (checkpoint != CHECKPOINT_CLOCK_WARP_START
|
|
|
|
/* FIXME: this is temporary fix, other checkpoints
|
|
|
|
may also be invoked from the different threads someday.
|
|
|
|
Asynchronous event processing should be refactored
|
|
|
|
to create additional replay event kind which is
|
|
|
|
nailed to the one of the threads and which processes
|
|
|
|
the event queue. */
|
|
|
|
&& checkpoint != CHECKPOINT_CLOCK_VIRTUAL) {
|
2018-02-27 10:53:16 +01:00
|
|
|
replay_save_events(checkpoint);
|
|
|
|
}
|
2015-09-17 18:24:44 +02:00
|
|
|
res = true;
|
|
|
|
}
|
|
|
|
out:
|
2018-02-27 10:53:05 +01:00
|
|
|
in_checkpoint = false;
|
2015-09-17 18:24:44 +02:00
|
|
|
return res;
|
|
|
|
}
|
2015-09-17 18:25:07 +02:00
|
|
|
|
2018-09-12 10:19:45 +02:00
|
|
|
bool replay_has_checkpoint(void)
|
|
|
|
{
|
|
|
|
bool res = false;
|
|
|
|
if (replay_mode == REPLAY_MODE_PLAY) {
|
|
|
|
g_assert(replay_mutex_locked());
|
|
|
|
replay_account_executed_instructions();
|
|
|
|
res = EVENT_CHECKPOINT <= replay_state.data_kind
|
|
|
|
&& replay_state.data_kind <= EVENT_CHECKPOINT_LAST;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2015-09-17 18:25:07 +02:00
|
|
|
static void replay_enable(const char *fname, int mode)
|
|
|
|
{
|
|
|
|
const char *fmode = NULL;
|
|
|
|
assert(!replay_file);
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case REPLAY_MODE_RECORD:
|
|
|
|
fmode = "wb";
|
|
|
|
break;
|
|
|
|
case REPLAY_MODE_PLAY:
|
|
|
|
fmode = "rb";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "Replay: internal error: invalid replay mode\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
atexit(replay_finish);
|
|
|
|
|
|
|
|
replay_file = fopen(fname, fmode);
|
|
|
|
if (replay_file == NULL) {
|
|
|
|
fprintf(stderr, "Replay: open %s: %s\n", fname, strerror(errno));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
replay_filename = g_strdup(fname);
|
|
|
|
replay_mode = mode;
|
2018-02-27 10:52:48 +01:00
|
|
|
replay_mutex_init();
|
|
|
|
|
2016-09-26 10:08:04 +02:00
|
|
|
replay_state.data_kind = -1;
|
2019-07-25 10:44:43 +02:00
|
|
|
replay_state.instruction_count = 0;
|
|
|
|
replay_state.current_icount = 0;
|
2016-09-26 10:08:04 +02:00
|
|
|
replay_state.has_unread_data = 0;
|
2015-09-17 18:25:07 +02:00
|
|
|
|
|
|
|
/* skip file header for RECORD and check it for PLAY */
|
|
|
|
if (replay_mode == REPLAY_MODE_RECORD) {
|
|
|
|
fseek(replay_file, HEADER_SIZE, SEEK_SET);
|
|
|
|
} else if (replay_mode == REPLAY_MODE_PLAY) {
|
|
|
|
unsigned int version = replay_get_dword();
|
|
|
|
if (version != REPLAY_VERSION) {
|
|
|
|
fprintf(stderr, "Replay: invalid input log file version\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
/* go to the beginning */
|
|
|
|
fseek(replay_file, HEADER_SIZE, SEEK_SET);
|
|
|
|
replay_fetch_data_kind();
|
|
|
|
}
|
|
|
|
|
|
|
|
replay_init_events();
|
|
|
|
}
|
|
|
|
|
|
|
|
void replay_configure(QemuOpts *opts)
|
|
|
|
{
|
|
|
|
const char *fname;
|
|
|
|
const char *rr;
|
|
|
|
ReplayMode mode = REPLAY_MODE_NONE;
|
2016-02-12 20:02:26 +01:00
|
|
|
Location loc;
|
|
|
|
|
|
|
|
if (!opts) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
loc_push_none(&loc);
|
|
|
|
qemu_opts_loc_restore(opts);
|
2015-09-17 18:25:07 +02:00
|
|
|
|
|
|
|
rr = qemu_opt_get(opts, "rr");
|
|
|
|
if (!rr) {
|
|
|
|
/* Just enabling icount */
|
2016-04-27 16:29:08 +02:00
|
|
|
goto out;
|
2015-09-17 18:25:07 +02:00
|
|
|
} else if (!strcmp(rr, "record")) {
|
|
|
|
mode = REPLAY_MODE_RECORD;
|
|
|
|
} else if (!strcmp(rr, "replay")) {
|
|
|
|
mode = REPLAY_MODE_PLAY;
|
|
|
|
} else {
|
|
|
|
error_report("Invalid icount rr option: %s", rr);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
fname = qemu_opt_get(opts, "rrfile");
|
|
|
|
if (!fname) {
|
|
|
|
error_report("File name not specified for replay");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2017-01-24 08:17:47 +01:00
|
|
|
replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot"));
|
2016-09-26 10:08:10 +02:00
|
|
|
replay_vmstate_register();
|
2015-09-17 18:25:07 +02:00
|
|
|
replay_enable(fname, mode);
|
2016-02-12 20:02:26 +01:00
|
|
|
|
2016-04-27 16:29:08 +02:00
|
|
|
out:
|
2016-02-12 20:02:26 +01:00
|
|
|
loc_pop(&loc);
|
2015-09-17 18:25:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void replay_start(void)
|
|
|
|
{
|
|
|
|
if (replay_mode == REPLAY_MODE_NONE) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-09-17 18:25:13 +02:00
|
|
|
if (replay_blockers) {
|
2015-12-18 16:35:14 +01:00
|
|
|
error_reportf_err(replay_blockers->data, "Record/replay: ");
|
2015-09-17 18:25:13 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2020-08-19 13:17:19 +02:00
|
|
|
if (!icount_enabled()) {
|
2015-09-17 18:25:18 +02:00
|
|
|
error_report("Please enable icount to use record/replay");
|
|
|
|
exit(1);
|
|
|
|
}
|
2015-09-17 18:25:13 +02:00
|
|
|
|
2015-09-17 18:25:07 +02:00
|
|
|
/* Timer for snapshotting will be set up here. */
|
|
|
|
|
|
|
|
replay_enable_events();
|
|
|
|
}
|
|
|
|
|
|
|
|
void replay_finish(void)
|
|
|
|
{
|
|
|
|
if (replay_mode == REPLAY_MODE_NONE) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
replay_save_instructions();
|
|
|
|
|
|
|
|
/* finalize the file */
|
|
|
|
if (replay_file) {
|
|
|
|
if (replay_mode == REPLAY_MODE_RECORD) {
|
2020-05-22 08:45:54 +02:00
|
|
|
/*
|
|
|
|
* Can't do it in the signal handler, therefore
|
|
|
|
* add shutdown event here for the case of Ctrl-C.
|
|
|
|
*/
|
|
|
|
replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL);
|
2015-09-17 18:25:07 +02:00
|
|
|
/* write end event */
|
|
|
|
replay_put_event(EVENT_END);
|
|
|
|
|
|
|
|
/* write header */
|
|
|
|
fseek(replay_file, 0, SEEK_SET);
|
|
|
|
replay_put_dword(REPLAY_VERSION);
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(replay_file);
|
|
|
|
replay_file = NULL;
|
|
|
|
}
|
|
|
|
if (replay_filename) {
|
|
|
|
g_free(replay_filename);
|
|
|
|
replay_filename = NULL;
|
|
|
|
}
|
|
|
|
|
2017-01-24 08:17:47 +01:00
|
|
|
g_free(replay_snapshot);
|
|
|
|
replay_snapshot = NULL;
|
|
|
|
|
2019-09-17 13:58:13 +02:00
|
|
|
replay_mode = REPLAY_MODE_NONE;
|
|
|
|
|
2015-09-17 18:25:07 +02:00
|
|
|
replay_finish_events();
|
|
|
|
}
|
2015-09-17 18:25:13 +02:00
|
|
|
|
|
|
|
void replay_add_blocker(Error *reason)
|
|
|
|
{
|
|
|
|
replay_blockers = g_slist_prepend(replay_blockers, reason);
|
|
|
|
}
|