/*
* replay-internal.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 "sysemu/replay.h"
#include "sysemu/runstate.h"
#include "replay-internal.h"
#include "qemu/error-report.h"
#include "qemu/main-loop.h"
/* Mutex to protect reading and writing events to the log.
data_kind and has_unread_data are also protected
by this mutex.
It also protects replay events queue which stores events to be
written or read to the log. */
static QemuMutex lock;
/* Condition and queue for fair ordering of mutex lock requests. */
static QemuCond mutex_cond;
static unsigned long mutex_head, mutex_tail;
/* File for replay writing */
static bool write_error;
FILE *replay_file;
static void replay_write_error(void)
{
if (!write_error) {
error_report("replay write error");
write_error = true;
}
}
static void replay_read_error(void)
{
error_report("error reading the replay data");
exit(1);
}
void replay_put_byte(uint8_t byte)
{
if (replay_file) {
if (putc(byte, replay_file) == EOF) {
replay_write_error();
}
}
}
void replay_put_event(uint8_t event)
{
assert(event < EVENT_COUNT);
replay_put_byte(event);
}
void replay_put_word(uint16_t word)
{
replay_put_byte(word >> 8);
replay_put_byte(word);
}
void replay_put_dword(uint32_t dword)
{
replay_put_word(dword >> 16);
replay_put_word(dword);
}
void replay_put_qword(int64_t qword)
{
replay_put_dword(qword >> 32);
replay_put_dword(qword);
}
void replay_put_array(const uint8_t *buf, size_t size)
{
if (replay_file) {
replay_put_dword(size);
if (fwrite(buf, 1, size, replay_file) != size) {
replay_write_error();
}
}
}
uint8_t replay_get_byte(void)
{
uint8_t byte = 0;
if (replay_file) {
int r = getc(replay_file);
if (r == EOF) {
replay_read_error();
}
byte = r;
}
return byte;
}
uint16_t replay_get_word(void)
{
uint16_t word = 0;
if (replay_file) {
word = replay_get_byte();
word = (word << 8) + replay_get_byte();
}
return word;
}
uint32_t replay_get_dword(void)
{
uint32_t dword = 0;
if (replay_file) {
dword = replay_get_word();
dword = (dword << 16) + replay_get_word();
}
return dword;
}
int64_t replay_get_qword(void)
{
int64_t qword = 0;
if (replay_file) {
qword = replay_get_dword();
qword = (qword << 32) + replay_get_dword();
}
return qword;
}
void replay_get_array(uint8_t *buf, size_t *size)
{
if (replay_file) {
*size = replay_get_dword();
if (fread(buf, 1, *size, replay_file) != *size) {
replay_read_error();
}
}
}
void replay_get_array_alloc(uint8_t **buf, size_t *size)
{
if (replay_file) {
*size = replay_get_dword();
*buf = g_malloc(*size);
if (fread(*buf, 1, *size, replay_file) != *size) {
replay_read_error();
}
}
}
void replay_check_error(void)
{
if (replay_file) {
if (feof(replay_file)) {
error_report("replay file is over");
qemu_system_vmstop_request_prepare();
qemu_system_vmstop_request(RUN_STATE_PAUSED);
} else if (ferror(replay_file)) {
error_report("replay file is over or something goes wrong");
qemu_system_vmstop_request_prepare();
qemu_system_vmstop_request(RUN_STATE_INTERNAL_ERROR);
}
}
}
void replay_fetch_data_kind(void)
{
if (replay_file) {
if (!replay_state.has_unread_data) {
replay_state.data_kind = replay_get_byte();
if (replay_state.data_kind == EVENT_INSTRUCTION) {
replay_state.instruction_count = replay_get_dword();
}
replay_check_error();
replay_state.has_unread_data = 1;
if (replay_state.data_kind >= EVENT_COUNT) {
error_report("Replay: unknown event kind %d",
replay_state.data_kind);
exit(1);
}
}
}
}
void replay_finish_event(void)
{
replay_state.has_unread_data = 0;
replay_fetch_data_kind();
}
static __thread bool replay_locked;
void replay_mutex_init(void)
{
qemu_mutex_init(&lock);
qemu_cond_init(&mutex_cond);
/* Hold the mutex while we start-up */
replay_locked = true;
++mutex_tail;
}
bool replay_mutex_locked(void)
{
return replay_locked;
}
/* Ordering constraints, replay_lock must be taken before BQL */
void replay_mutex_lock(void)
{
if (replay_mode != REPLAY_MODE_NONE) {
unsigned long id;
g_assert(!qemu_mutex_iothread_locked());
g_assert(!replay_mutex_locked());
qemu_mutex_lock(&lock);
id = mutex_tail++;
while (id != mutex_head) {
qemu_cond_wait(&mutex_cond, &lock);
}
replay_locked = true;
qemu_mutex_unlock(&lock);
}
}
void replay_mutex_unlock(void)
{
if (replay_mode != REPLAY_MODE_NONE) {
g_assert(replay_mutex_locked());
qemu_mutex_lock(&lock);
++mutex_head;
replay_locked = false;
qemu_cond_broadcast(&mutex_cond);
qemu_mutex_unlock(&lock);
}
}
void replay_advance_current_icount(uint64_t current_icount)
{
int diff = (int)(current_icount - replay_state.current_icount);
/* Time can only go forward */
assert(diff >= 0);
if (replay_mode == REPLAY_MODE_RECORD) {
if (diff > 0) {
replay_put_event(EVENT_INSTRUCTION);
replay_put_dword(diff);
replay_state.current_icount += diff;
}
} else if (replay_mode == REPLAY_MODE_PLAY) {
if (diff > 0) {
replay_state.instruction_count -= diff;
replay_state.current_icount += diff;
if (replay_state.instruction_count == 0) {
assert(replay_state.data_kind == EVENT_INSTRUCTION);
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();
}
}
/* Execution reached the break step */
if (replay_break_icount == replay_state.current_icount) {
/* Cannot make callback directly from the vCPU thread */
timer_mod_ns(replay_break_timer,
qemu_clock_get_ns(QEMU_CLOCK_REALTIME));
}
}
}
/*! Saves cached instructions. */
void replay_save_instructions(void)
{
if (replay_file && replay_mode == REPLAY_MODE_RECORD) {
g_assert(replay_mutex_locked());
replay_advance_current_icount(replay_get_current_icount());
}
}
