[mirror_qemu.git] / replay / replay.c

/*
 * 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.
 *
 */

#include "qemu/osdep.h"
#include "qapi/error.h"
#include "sysemu/cpu-timers.h"
#include "sysemu/replay.h"
#include "sysemu/runstate.h"
#include "replay-internal.h"
#include "qemu/main-loop.h"
#include "qemu/option.h"
#include "sysemu/cpus.h"
#include "qemu/error-report.h"

/* Current version of the replay mechanism.
   Increase it when file format changes. */
#define REPLAY_VERSION              0xe0200c
/* Size of replay log header */
#define HEADER_SIZE                 (sizeof(uint32_t) + sizeof(uint64_t))

ReplayMode replay_mode = REPLAY_MODE_NONE;
char *replay_snapshot;

/* Name of replay file  */
static char *replay_filename;
ReplayState replay_state;
static GSList *replay_blockers;

/* Replay breakpoints */
uint64_t replay_break_icount = -1ULL;
QEMUTimer *replay_break_timer;

/* Pretty print event names */

static const char *replay_async_event_name(ReplayAsyncEventKind event)
{
    switch (event) {
#define ASYNC_EVENT(_x) case REPLAY_ASYNC_EVENT_ ## _x: return "ASYNC_EVENT_"#_x
        ASYNC_EVENT(BH);
        ASYNC_EVENT(BH_ONESHOT);
        ASYNC_EVENT(INPUT);
        ASYNC_EVENT(INPUT_SYNC);
        ASYNC_EVENT(CHAR_READ);
        ASYNC_EVENT(BLOCK);
        ASYNC_EVENT(NET);
#undef ASYNC_EVENT
    default:
        g_assert_not_reached();
    }
}

static const char *replay_clock_event_name(ReplayClockKind clock)
{
    switch (clock) {
#define CLOCK_EVENT(_x) case REPLAY_CLOCK_ ## _x: return "CLOCK_" #_x
        CLOCK_EVENT(HOST);
        CLOCK_EVENT(VIRTUAL_RT);
#undef CLOCK_EVENT
    default:
        g_assert_not_reached();
    }
}

/* Pretty print shutdown event names */
static const char *replay_shutdown_event_name(ShutdownCause cause)
{
    switch (cause) {
#define SHUTDOWN_EVENT(_x) case SHUTDOWN_CAUSE_ ## _x: return "SHUTDOWN_CAUSE_" #_x
        SHUTDOWN_EVENT(NONE);
        SHUTDOWN_EVENT(HOST_ERROR);
        SHUTDOWN_EVENT(HOST_QMP_QUIT);
        SHUTDOWN_EVENT(HOST_QMP_SYSTEM_RESET);
        SHUTDOWN_EVENT(HOST_SIGNAL);
        SHUTDOWN_EVENT(HOST_UI);
        SHUTDOWN_EVENT(GUEST_SHUTDOWN);
        SHUTDOWN_EVENT(GUEST_RESET);
        SHUTDOWN_EVENT(GUEST_PANIC);
        SHUTDOWN_EVENT(SUBSYSTEM_RESET);
        SHUTDOWN_EVENT(SNAPSHOT_LOAD);
#undef SHUTDOWN_EVENT
    default:
        g_assert_not_reached();
    }
}

static const char *replay_checkpoint_event_name(enum ReplayCheckpoint checkpoint)
{
    switch (checkpoint) {
#define CHECKPOINT_EVENT(_x) case CHECKPOINT_ ## _x: return "CHECKPOINT_" #_x
        CHECKPOINT_EVENT(CLOCK_WARP_START);
        CHECKPOINT_EVENT(CLOCK_WARP_ACCOUNT);
        CHECKPOINT_EVENT(RESET_REQUESTED);
        CHECKPOINT_EVENT(SUSPEND_REQUESTED);
        CHECKPOINT_EVENT(CLOCK_VIRTUAL);
        CHECKPOINT_EVENT(CLOCK_HOST);
        CHECKPOINT_EVENT(CLOCK_VIRTUAL_RT);
        CHECKPOINT_EVENT(INIT);
        CHECKPOINT_EVENT(RESET);
#undef CHECKPOINT_EVENT
    default:
        g_assert_not_reached();
    }
}

static const char *replay_event_name(enum ReplayEvents event)
{
    /* First deal with the simple ones */
    switch (event) {
#define EVENT(_x) case EVENT_ ## _x: return "EVENT_"#_x
        EVENT(INSTRUCTION);
        EVENT(INTERRUPT);
        EVENT(EXCEPTION);
        EVENT(CHAR_WRITE);
        EVENT(CHAR_READ_ALL);
        EVENT(AUDIO_OUT);
        EVENT(AUDIO_IN);
        EVENT(RANDOM);
#undef EVENT
    default:
        if (event >= EVENT_ASYNC && event <= EVENT_ASYNC_LAST) {
            return replay_async_event_name(event - EVENT_ASYNC);
        } else if (event >= EVENT_SHUTDOWN && event <= EVENT_SHUTDOWN_LAST) {
            return replay_shutdown_event_name(event - EVENT_SHUTDOWN);
        } else if (event >= EVENT_CLOCK && event <= EVENT_CLOCK_LAST) {
            return replay_clock_event_name(event - EVENT_CLOCK);
        } else if (event >= EVENT_CHECKPOINT && event <= EVENT_CHECKPOINT_LAST) {
            return replay_checkpoint_event_name(event - EVENT_CHECKPOINT);
        }
    }

    g_assert_not_reached();
}

bool replay_next_event_is(int event)
{
    bool res = false;

    /* nothing to skip - not all instructions used */
    if (replay_state.instruction_count != 0) {
        assert(replay_state.data_kind == EVENT_INSTRUCTION);
        return event == EVENT_INSTRUCTION;
    }

    while (true) {
        unsigned int data_kind = replay_state.data_kind;
        if (event == data_kind) {
            res = true;
        }
        switch (data_kind) {
        case EVENT_SHUTDOWN ... EVENT_SHUTDOWN_LAST:
            replay_finish_event();
            qemu_system_shutdown_request(data_kind - EVENT_SHUTDOWN);
            break;
        default:
            /* clock, time_t, checkpoint and other events */
            return res;
        }
    }
    return res;
}

uint64_t replay_get_current_icount(void)
{
    return icount_get_raw();
}

int replay_get_instructions(void)
{
    int res = 0;
    g_assert(replay_mutex_locked());
    if (replay_next_event_is(EVENT_INSTRUCTION)) {
        res = replay_state.instruction_count;
        if (replay_break_icount != -1LL) {
            uint64_t current = replay_get_current_icount();
            assert(replay_break_icount >= current);
            if (current + res > replay_break_icount) {
                res = replay_break_icount - current;
            }
        }
    }
    return res;
}

void replay_account_executed_instructions(void)
{
    if (replay_mode == REPLAY_MODE_PLAY) {
        g_assert(replay_mutex_locked());
        if (replay_state.instruction_count > 0) {
            replay_advance_current_icount(replay_get_current_icount());
        }
    }
}

bool replay_exception(void)
{

    if (replay_mode == REPLAY_MODE_RECORD) {
        g_assert(replay_mutex_locked());
        replay_save_instructions();
        replay_put_event(EVENT_EXCEPTION);
        return true;
    } else if (replay_mode == REPLAY_MODE_PLAY) {
        g_assert(replay_mutex_locked());
        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) {
        g_assert(replay_mutex_locked());
        replay_account_executed_instructions();
        res = replay_next_event_is(EVENT_EXCEPTION);
    }

    return res;
}

bool replay_interrupt(void)
{
    if (replay_mode == REPLAY_MODE_RECORD) {
        g_assert(replay_mutex_locked());
        replay_save_instructions();
        replay_put_event(EVENT_INTERRUPT);
        return true;
    } else if (replay_mode == REPLAY_MODE_PLAY) {
        g_assert(replay_mutex_locked());
        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) {
        g_assert(replay_mutex_locked());
        replay_account_executed_instructions();
        res = replay_next_event_is(EVENT_INTERRUPT);
    }
    return res;
}

void replay_shutdown_request(ShutdownCause cause)
{
    if (replay_mode == REPLAY_MODE_RECORD) {
        g_assert(replay_mutex_locked());
        replay_put_event(EVENT_SHUTDOWN + cause);
    }
}

bool replay_checkpoint(ReplayCheckpoint checkpoint)
{
    assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);

    replay_save_instructions();

    if (replay_mode == REPLAY_MODE_PLAY) {
        g_assert(replay_mutex_locked());
        if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
            replay_finish_event();
        } else {
            return false;
        }
    } else if (replay_mode == REPLAY_MODE_RECORD) {
        g_assert(replay_mutex_locked());
        replay_put_event(EVENT_CHECKPOINT + checkpoint);
    }
    return true;
}

void replay_async_events(void)
{
    static bool processing = false;
    /*
     * If we are already processing the events, recursion may occur
     * in case of incorrect implementation when HW event modifies timers.
     * Timer modification may invoke the icount warp, event processing,
     * and cause the recursion.
     */
    g_assert(!processing);
    processing = true;

    replay_save_instructions();

    if (replay_mode == REPLAY_MODE_PLAY) {
        g_assert(replay_mutex_locked());
        replay_read_events();
    } else if (replay_mode == REPLAY_MODE_RECORD) {
        g_assert(replay_mutex_locked());
        replay_save_events();
    }
    processing = false;
}

bool replay_has_event(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;
        res = res || (EVENT_ASYNC <= replay_state.data_kind
                     && replay_state.data_kind <= EVENT_ASYNC_LAST);
    }
    return res;
}

G_NORETURN void replay_sync_error(const char *error)
{
    error_report("%s (insn total %"PRId64"/%d left, event %d is %s)", error,
                 replay_state.current_icount, replay_state.instruction_count,
                 replay_state.current_event,
                 replay_event_name(replay_state.data_kind));
    abort();
}

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;
    replay_mutex_init();

    replay_state.data_kind = -1;
    replay_state.instruction_count = 0;
    replay_state.current_icount = 0;
    replay_state.current_event = 0;
    replay_state.has_unread_data = 0;

    /* 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;
    Location loc;

    if (!opts) {
        return;
    }

    loc_push_none(&loc);
    qemu_opts_loc_restore(opts);

    rr = qemu_opt_get(opts, "rr");
    if (!rr) {
        /* Just enabling icount */
        goto out;
    } 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);
    }

    replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot"));
    replay_vmstate_register();
    replay_enable(fname, mode);

out:
    loc_pop(&loc);
}

void replay_start(void)
{
    if (replay_mode == REPLAY_MODE_NONE) {
        return;
    }

    if (replay_blockers) {
        error_reportf_err(replay_blockers->data, "Record/replay: ");
        exit(1);
    }
    if (!icount_enabled()) {
        error_report("Please enable icount to use record/replay");
        exit(1);
    }

    /* Timer for snapshotting will be set up here. */

    replay_enable_events();
}

/*
 * For none/record the answer is yes.
 */
bool replay_can_wait(void)
{
    if (replay_mode == REPLAY_MODE_PLAY) {
        /*
         * For playback we shouldn't ever be at a point we wait. If
         * the instruction count has reached zero and we have an
         * unconsumed event we should go around again and consume it.
         */
        if (replay_state.instruction_count == 0 && replay_state.has_unread_data) {
            return false;
        } else {
            replay_sync_error("Playback shouldn't have to iowait");
        }
    }
    return true;
}


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) {
            /*
             * 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);
            /* 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;
    }
    g_free(replay_filename);
    replay_filename = NULL;

    g_free(replay_snapshot);
    replay_snapshot = NULL;

    replay_finish_events();
    replay_mode = REPLAY_MODE_NONE;
}

void replay_add_blocker(const char *feature)
{
    Error *reason = NULL;

    error_setg(&reason, "Record/replay feature is not supported for '%s'",
               feature);
    replay_blockers = g_slist_prepend(replay_blockers, reason);
}

const char *replay_get_filename(void)
{
    return replay_filename;
}
Commit	Line	Data
d73abd6d PD	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
d38ea87a	12	#include "qemu/osdep.h"
da34e65c	13	#include "qapi/error.h"
740b1759	14	#include "sysemu/cpu-timers.h"
d73abd6d	15	#include "sysemu/replay.h"
54d31236	16	#include "sysemu/runstate.h"
26bc60ac	17	#include "replay-internal.h"
8b427044	18	#include "qemu/main-loop.h"
922a01a0	19	#include "qemu/option.h"
d2528bdc	20	#include "sysemu/cpus.h"
7615936e PD	21	#include "qemu/error-report.h"
	22
	23	/* Current version of the replay mechanism.
	24	Increase it when file format changes. */
3e21408b	25	#define REPLAY_VERSION 0xe0200c
7615936e PD	26	/* Size of replay log header */
7615936e PD	27	#define HEADER_SIZE (sizeof(uint32_t) + sizeof(uint64_t))
d73abd6d PD	28
d73abd6d PD	29	ReplayMode replay_mode = REPLAY_MODE_NONE;
9c2037d0	30	char *replay_snapshot;
26bc60ac	31
7615936e PD	32	/* Name of replay file */
7615936e PD	33	static char *replay_filename;
26bc60ac	34	ReplayState replay_state;
0194749a	35	static GSList *replay_blockers;
26bc60ac	36
e7510671 PD	37	/* Replay breakpoints */
	38	uint64_t replay_break_icount = -1ULL;
	39	QEMUTimer *replay_break_timer;
	40
dcda7321 AB	41	/* Pretty print event names */
	42
	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
	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 */
	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
	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
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
26bc60ac PD	142	bool replay_next_event_is(int event)
	143	{
	144	bool res = false;
	145
	146	/* nothing to skip - not all instructions used */
13f26713	147	if (replay_state.instruction_count != 0) {
f186d64d	148	assert(replay_state.data_kind == EVENT_INSTRUCTION);
26bc60ac PD	149	return event == EVENT_INSTRUCTION;
	150	}
	151
	152	while (true) {
e957ad8a PD	153	unsigned int data_kind = replay_state.data_kind;
e957ad8a PD	154	if (event == data_kind) {
26bc60ac PD	155	res = true;
26bc60ac PD	156	}
e957ad8a	157	switch (data_kind) {
802f045a	158	case EVENT_SHUTDOWN ... EVENT_SHUTDOWN_LAST:
b60c48a7	159	replay_finish_event();
e957ad8a	160	qemu_system_shutdown_request(data_kind - EVENT_SHUTDOWN);
b60c48a7	161	break;
26bc60ac PD	162	default:
	163	/* clock, time_t, checkpoint and other events */
	164	return res;
	165	}
	166	}
	167	return res;
	168	}
	169
13f26713	170	uint64_t replay_get_current_icount(void)
26bc60ac	171	{
8191d368	172	return icount_get_raw();
26bc60ac	173	}
8b427044 PD	174
	175	int replay_get_instructions(void)
	176	{
	177	int res = 0;
83ecdb18	178	g_assert(replay_mutex_locked());
8b427044	179	if (replay_next_event_is(EVENT_INSTRUCTION)) {
13f26713	180	res = replay_state.instruction_count;
e7510671 PD	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	}
8b427044	188	}
8b427044 PD	189	return res;
	190	}
	191
	192	void replay_account_executed_instructions(void)
	193	{
	194	if (replay_mode == REPLAY_MODE_PLAY) {
d759c951	195	g_assert(replay_mutex_locked());
13f26713	196	if (replay_state.instruction_count > 0) {
366a85e4	197	replay_advance_current_icount(replay_get_current_icount());
8b427044	198	}
8b427044 PD	199	}
8b427044 PD	200	}
6f060969 PD	201
	202	bool replay_exception(void)
	203	{
d759c951	204
6f060969	205	if (replay_mode == REPLAY_MODE_RECORD) {
d759c951	206	g_assert(replay_mutex_locked());
6f060969	207	replay_save_instructions();
6f060969	208	replay_put_event(EVENT_EXCEPTION);
6f060969 PD	209	return true;
6f060969 PD	210	} else if (replay_mode == REPLAY_MODE_PLAY) {
d759c951	211	g_assert(replay_mutex_locked());
6f060969 PD	212	bool res = replay_has_exception();
6f060969 PD	213	if (res) {
6f060969	214	replay_finish_event();
6f060969 PD	215	}
	216	return res;
	217	}
	218
	219	return true;
	220	}
	221
	222	bool replay_has_exception(void)
	223	{
	224	bool res = false;
	225	if (replay_mode == REPLAY_MODE_PLAY) {
d759c951	226	g_assert(replay_mutex_locked());
6f060969	227	replay_account_executed_instructions();
6f060969	228	res = replay_next_event_is(EVENT_EXCEPTION);
6f060969 PD	229	}
	230
	231	return res;
	232	}
	233
	234	bool replay_interrupt(void)
	235	{
	236	if (replay_mode == REPLAY_MODE_RECORD) {
d759c951	237	g_assert(replay_mutex_locked());
6f060969	238	replay_save_instructions();
6f060969	239	replay_put_event(EVENT_INTERRUPT);
6f060969 PD	240	return true;
6f060969 PD	241	} else if (replay_mode == REPLAY_MODE_PLAY) {
d759c951	242	g_assert(replay_mutex_locked());
6f060969 PD	243	bool res = replay_has_interrupt();
6f060969 PD	244	if (res) {
6f060969	245	replay_finish_event();
6f060969 PD	246	}
	247	return res;
	248	}
	249
	250	return true;
	251	}
	252
	253	bool replay_has_interrupt(void)
	254	{
	255	bool res = false;
	256	if (replay_mode == REPLAY_MODE_PLAY) {
d759c951	257	g_assert(replay_mutex_locked());
6f060969	258	replay_account_executed_instructions();
6f060969	259	res = replay_next_event_is(EVENT_INTERRUPT);
6f060969 PD	260	}
	261	return res;
	262	}
b60c48a7	263
802f045a	264	void replay_shutdown_request(ShutdownCause cause)
b60c48a7 PD	265	{
b60c48a7 PD	266	if (replay_mode == REPLAY_MODE_RECORD) {
d759c951	267	g_assert(replay_mutex_locked());
802f045a	268	replay_put_event(EVENT_SHUTDOWN + cause);
b60c48a7 PD	269	}
b60c48a7 PD	270	}
8bd7f71d PD	271
	272	bool replay_checkpoint(ReplayCheckpoint checkpoint)
	273	{
8bd7f71d	274	assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);
8bd7f71d	275
66eb7825	276	replay_save_instructions();
8bd7f71d PD	277
8bd7f71d PD	278	if (replay_mode == REPLAY_MODE_PLAY) {
d759c951	279	g_assert(replay_mutex_locked());
8bd7f71d PD	280	if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
8bd7f71d PD	281	replay_finish_event();
60618e2d PD	282	} else {
60618e2d PD	283	return false;
8bd7f71d	284	}
8bd7f71d	285	} else if (replay_mode == REPLAY_MODE_RECORD) {
d759c951	286	g_assert(replay_mutex_locked());
8bd7f71d	287	replay_put_event(EVENT_CHECKPOINT + checkpoint);
8bd7f71d	288	}
60618e2d PD	289	return true;
	290	}
	291
	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;
8bd7f71d	314	}
7615936e	315
60618e2d	316	bool replay_has_event(void)
0c08185f PD	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;
3e21408b PD	324	res = res \|\| (EVENT_ASYNC <= replay_state.data_kind
3e21408b PD	325	&& replay_state.data_kind <= EVENT_ASYNC_LAST);
0c08185f PD	326	}
	327	return res;
	328	}
	329
dcda7321 AB	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
7615936e PD	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
7615936e PD	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);
7615936e	365	replay_mode = mode;
d759c951 AB	366	replay_mutex_init();
d759c951 AB	367
f186d64d	368	replay_state.data_kind = -1;
13f26713 PD	369	replay_state.instruction_count = 0;
13f26713 PD	370	replay_state.current_icount = 0;
dcda7321	371	replay_state.current_event = 0;
f186d64d	372	replay_state.has_unread_data = 0;
7615936e PD	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	replay_init_events();
	389	}
	390
	391	void replay_configure(QemuOpts *opts)
	392	{
	393	const char *fname;
	394	const char *rr;
	395	ReplayMode mode = REPLAY_MODE_NONE;
890ad550 EH	396	Location loc;
	397
	398	if (!opts) {
	399	return;
	400	}
	401
	402	loc_push_none(&loc);
	403	qemu_opts_loc_restore(opts);
7615936e PD	404
	405	rr = qemu_opt_get(opts, "rr");
	406	if (!rr) {
	407	/* Just enabling icount */
d9d3aaea	408	goto out;
7615936e PD	409	} else if (!strcmp(rr, "record")) {
	410	mode = REPLAY_MODE_RECORD;
	411	} else if (!strcmp(rr, "replay")) {
	412	mode = REPLAY_MODE_PLAY;
	413	} else {
	414	error_report("Invalid icount rr option: %s", rr);
	415	exit(1);
	416	}
	417
	418	fname = qemu_opt_get(opts, "rrfile");
	419	if (!fname) {
	420	error_report("File name not specified for replay");
	421	exit(1);
	422	}
	423
9c2037d0	424	replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot"));
306e196f	425	replay_vmstate_register();
7615936e	426	replay_enable(fname, mode);
890ad550	427
d9d3aaea	428	out:
890ad550	429	loc_pop(&loc);
7615936e PD	430	}
	431
	432	void replay_start(void)
	433	{
	434	if (replay_mode == REPLAY_MODE_NONE) {
	435	return;
	436	}
	437
0194749a	438	if (replay_blockers) {
c29b77f9	439	error_reportf_err(replay_blockers->data, "Record/replay: ");
0194749a PD	440	exit(1);
0194749a PD	441	}
740b1759	442	if (!icount_enabled()) {
4c27b859 PD	443	error_report("Please enable icount to use record/replay");
	444	exit(1);
	445	}
0194749a	446
7615936e PD	447	/* Timer for snapshotting will be set up here. */
	448
	449	replay_enable_events();
	450	}
	451
1f881ea4 AB	452	/*
	453	* For none/record the answer is yes.
	454	*/
	455	bool replay_can_wait(void)
	456	{
	457	if (replay_mode == REPLAY_MODE_PLAY) {
	458	/*
	459	* For playback we shouldn't ever be at a point we wait. If
	460	* the instruction count has reached zero and we have an
	461	* unconsumed event we should go around again and consume it.
	462	*/
	463	if (replay_state.instruction_count == 0 && replay_state.has_unread_data) {
	464	return false;
	465	} else {
	466	replay_sync_error("Playback shouldn't have to iowait");
	467	}
	468	}
	469	return true;
	470	}
	471
	472
7615936e PD	473	void replay_finish(void)
	474	{
	475	if (replay_mode == REPLAY_MODE_NONE) {
	476	return;
	477	}
	478
	479	replay_save_instructions();
	480
	481	/* finalize the file */
	482	if (replay_file) {
	483	if (replay_mode == REPLAY_MODE_RECORD) {
ed5d7ff3 PD	484	/*
	485	* Can't do it in the signal handler, therefore
	486	* add shutdown event here for the case of Ctrl-C.
	487	*/
	488	replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL);
7615936e PD	489	/* write end event */
	490	replay_put_event(EVENT_END);
	491
	492	/* write header */
	493	fseek(replay_file, 0, SEEK_SET);
	494	replay_put_dword(REPLAY_VERSION);
	495	}
	496
	497	fclose(replay_file);
	498	replay_file = NULL;
	499	}
76eb88b1 MA	500	g_free(replay_filename);
76eb88b1 MA	501	replay_filename = NULL;
7615936e	502
9c2037d0 PD	503	g_free(replay_snapshot);
	504	replay_snapshot = NULL;
	505
7615936e	506	replay_finish_events();
c4b8ffcb	507	replay_mode = REPLAY_MODE_NONE;
7615936e	508	}
0194749a	509
0ec8384f	510	void replay_add_blocker(const char *feature)
0194749a	511	{
0ec8384f MA	512	Error *reason = NULL;
	513
	514	error_setg(&reason, "Record/replay feature is not supported for '%s'",
	515	feature);
0194749a PD	516	replay_blockers = g_slist_prepend(replay_blockers, reason);
0194749a PD	517	}
56db1198 PD	518
	519	const char *replay_get_filename(void)
	520	{
	521	return replay_filename;
	522	}