@@ -22,6 +22,7 @@
#include "tcg.h"
#include "qemu/atomic.h"
#include "sysemu/qtest.h"
+#include "qemu/main-loop.h"
void cpu_loop_exit(CPUState *cpu)
{
@@ -283,19 +284,24 @@ int cpu_exec(CPUArchState *env)
#else
#error unsupported target CPU
#endif
- cpu->exception_index = -1;
-
/* prepare setjmp context for exception handling */
for(;;) {
if (sigsetjmp(cpu->jmp_env, 0) == 0) {
/* if an exception is pending, we execute it here */
if (cpu->exception_index >= 0) {
+ if (cpu->exception_index == EXCP_REPLAY) {
+ ret = cpu->exception_index;
+ cpu->exception_index = -1;
+ qemu_notify_event();
+ break;
+ }
if (cpu->exception_index >= EXCP_INTERRUPT) {
/* exit request from the cpu execution loop */
ret = cpu->exception_index;
if (ret == EXCP_DEBUG) {
cpu_handle_debug_exception(env);
}
+ cpu->exception_index = -1;
break;
} else {
#if defined(CONFIG_USER_ONLY)
@@ -601,6 +607,10 @@ int cpu_exec(CPUArchState *env)
next_tb = 0;
}
}
+ if (cpu->exception_index == EXCP_REPLAY) {
+ /* go to exception_index checking */
+ break;
+ }
if (unlikely(cpu->exit_request)) {
cpu->exit_request = 0;
cpu->exception_index = EXCP_INTERRUPT;
@@ -937,6 +937,8 @@ static void *qemu_tcg_cpu_thread_fn(void *arg)
CPU_FOREACH(cpu) {
cpu->thread_id = qemu_get_thread_id();
cpu->created = true;
+ /* init exception index here */
+ cpu->exception_index = -1;
}
qemu_cond_signal(&qemu_cpu_cond);
@@ -1186,6 +1188,7 @@ void qemu_init_vcpu(CPUState *cpu)
cpu->nr_cores = smp_cores;
cpu->nr_threads = smp_threads;
cpu->stopped = true;
+ cpu->instructions_count = 0;
if (kvm_enabled()) {
qemu_kvm_start_vcpu(cpu);
} else if (tcg_enabled()) {
@@ -1307,6 +1310,8 @@ static void tcg_exec_all(void)
if (r == EXCP_DEBUG) {
cpu_handle_guest_debug(cpu);
break;
+ } else if (r == EXCP_REPLAY) {
+ break;
}
} else if (cpu->stop || cpu->stopped) {
break;
@@ -52,6 +52,7 @@
#include "exec/ram_addr.h"
#include "qemu/range.h"
+#include "replay/replay.h"
//#define DEBUG_SUBPAGE
@@ -1649,6 +1650,9 @@ static void check_watchpoint(int offset, int len_mask, int flags)
if (!cpu->watchpoint_hit) {
cpu->watchpoint_hit = wp;
tb_check_watchpoint(cpu);
+ /* Current instruction is already processed by replay.
+ Set flags that allow skpping this events */
+ replay_undo_last_instruction();
if (wp->flags & BP_STOP_BEFORE_ACCESS) {
cpu->exception_index = EXCP_DEBUG;
cpu_loop_exit(cpu);
@@ -59,6 +59,8 @@ typedef uint64_t target_ulong;
#define EXCP_DEBUG 0x10002 /* cpu stopped after a breakpoint or singlestep */
#define EXCP_HALTED 0x10003 /* cpu is halted (waiting for external event) */
#define EXCP_YIELD 0x10004 /* cpu wants to yield timeslice to another */
+#define EXCP_REPLAY 0x10005 /* for breaking execution loop to make
+ correct order of events */
/* Only the bottom TB_JMP_PAGE_BITS of the jump cache hash bits vary for
addresses on the same page. The top bits are the same. This allows
@@ -287,6 +287,7 @@ struct CPUState {
(absolute value) offset as small as possible. This reduces code
size, especially for hosts without large memory offsets. */
volatile sig_atomic_t tcg_exit_req;
+ uint32_t instructions_count;
};
QTAILQ_HEAD(CPUTailQ, CPUState);
@@ -466,6 +467,8 @@ static inline bool cpu_has_work(CPUState *cpu)
*/
bool qemu_cpu_is_self(CPUState *cpu);
+bool qemu_in_vcpu_thread(void);
+
/**
* qemu_cpu_kick:
* @cpu: The vCPU to kick.
@@ -1,2 +1,3 @@
obj-y += replay.o
obj-y += replay-internal.o
+obj-y += replay-events.o
new file mode 100755
@@ -0,0 +1,26 @@
+/*
+ * replay-events.c
+ *
+ * Copyright (c) 2010-2014 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 "replay.h"
+#include "replay-internal.h"
+
+bool replay_has_events(void)
+{
+ return false;
+}
+
+void replay_save_events(int opt)
+{
+}
+
+void replay_read_events(int opt)
+{
+}
@@ -10,6 +10,7 @@
*/
#include "qemu-common.h"
+#include "replay.h"
#include "replay-internal.h"
volatile unsigned int replay_data_kind = -1;
@@ -139,3 +140,16 @@ void replay_fetch_data_kind(void)
}
}
}
+
+/*! Saves cached instructions. */
+void replay_save_instructions(void)
+{
+ if (replay_file && replay_mode == REPLAY_MODE_RECORD) {
+ if (first_cpu != NULL && first_cpu->instructions_count > 0) {
+ replay_put_event(EVENT_INSTRUCTION);
+ replay_put_dword(first_cpu->instructions_count);
+ replay_state.current_step += first_cpu->instructions_count;
+ first_cpu->instructions_count = 0;
+ }
+ }
+}
@@ -13,6 +13,21 @@
*/
#include <stdio.h>
+#include "sysemu/sysemu.h"
+
+/* for async events */
+#define EVENT_ASYNC 24
+/* for instruction event */
+#define EVENT_INSTRUCTION 32
+
+typedef struct ReplayState {
+ /*! Nonzero, when next instruction is repeated one and was already
+ processed. */
+ int skipping_instruction;
+ /*! Current step - number of processed instructions and timer events. */
+ uint64_t current_step;
+} ReplayState;
+extern ReplayState replay_state;
extern volatile unsigned int replay_data_kind;
extern volatile unsigned int replay_has_unread_data;
@@ -40,11 +55,27 @@ void replay_check_error(void);
/*! Reads data type from the file and stores it in the
replay_data_kind variable. */
void replay_fetch_data_kind(void);
-
-/*! Saves queued events (like instructions and sound). */
-void replay_save_instructions(void);
/*! Checks that the next data is corresponding to the desired kind.
Terminates the program in case of error. */
void validate_data_kind(int kind);
+/*! Saves queued events (like instructions and sound). */
+void replay_save_instructions(void);
+
+/*! Skips async events until some sync event will be found. */
+bool skip_async_events(int stop_event);
+/*! Skips async events invocations from the input,
+ until required data kind is found. If the requested data is not found
+ reports an error and stops the execution. */
+void skip_async_events_until(unsigned int kind);
+
+/* Asynchronous events queue */
+
+/*! Returns true if there are any unsaved events in the queue */
+bool replay_has_events(void);
+/*! Saves events from queue into the file */
+void replay_save_events(int opt);
+/*! Read events from the file into the input queue */
+void replay_read_events(int opt);
+
#endif
@@ -9,7 +9,9 @@
*
*/
+#include "qemu-common.h"
#include "replay.h"
+#include "replay-internal.h"
ReplayMode replay_mode = REPLAY_MODE_NONE;
/*! Stores current submode for PLAY mode */
@@ -18,8 +20,141 @@ ReplaySubmode play_submode = REPLAY_SUBMODE_UNKNOWN;
/* Suffix for the disk images filenames */
char *replay_image_suffix;
+ReplayState replay_state;
+
ReplaySubmode replay_get_play_submode(void)
{
return play_submode;
}
+
+bool skip_async_events(int stop_event)
+{
+ /* nothing to skip - not all instructions used */
+ if (first_cpu != NULL && first_cpu->instructions_count != 0
+ && replay_has_unread_data) {
+ return stop_event == EVENT_INSTRUCTION;
+ }
+
+ bool res = false;
+ while (true) {
+ replay_fetch_data_kind();
+ if (stop_event == replay_data_kind) {
+ res = true;
+ }
+ switch (replay_data_kind) {
+ case EVENT_INSTRUCTION:
+ first_cpu->instructions_count = replay_get_dword();
+ return res;
+ default:
+ /* clock, time_t, checkpoint and other events */
+ return res;
+ }
+ }
+
+ return res;
+}
+
+void skip_async_events_until(unsigned int kind)
+{
+ if (!skip_async_events(kind)) {
+ if (replay_data_kind == EVENT_ASYNC && kind == EVENT_INSTRUCTION) {
+ return;
+ }
+
+ fprintf(stderr, "%"PRId64": Read data kind %d instead of expected %d\n",
+ replay_get_current_step(), replay_data_kind, kind);
+ exit(1);
+ }
+}
+
+void replay_instruction(int process_events)
+{
+ if (replay_state.skipping_instruction) {
+ replay_state.skipping_instruction = 0;
+ return;
+ }
+
+ if (replay_file) {
+ if (replay_mode == REPLAY_MODE_RECORD) {
+ if (process_events && replay_has_events()) {
+ replay_save_instructions();
+ /* events will be after the last instruction */
+ replay_save_events(-1);
+ } else {
+ /* instruction - increase the step counter */
+ ++first_cpu->instructions_count;
+ }
+ } else if (replay_mode == REPLAY_MODE_PLAY) {
+ skip_async_events_until(EVENT_INSTRUCTION);
+ if (first_cpu->instructions_count >= 1) {
+ ++replay_state.current_step;
+ --first_cpu->instructions_count;
+ if (first_cpu->instructions_count == 0) {
+ replay_has_unread_data = 0;
+ }
+ } else {
+ replay_read_events(-1);
+ }
+ }
+ }
+}
+
+void replay_undo_last_instruction(void)
+{
+ if (replay_mode == REPLAY_MODE_RECORD) {
+ first_cpu->instructions_count--;
+ } else {
+ replay_state.skipping_instruction = 1;
+ }
+}
+
+bool replay_has_async_request(void)
+{
+ if (replay_state.skipping_instruction) {
+ return false;
+ }
+
+ if (replay_mode == REPLAY_MODE_PLAY) {
+ if (skip_async_events(EVENT_ASYNC)) {
+ return true;
+ }
+
+ return false;
+ } else if (replay_mode == REPLAY_MODE_RECORD) {
+ if (replay_has_events()) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool replay_has_instruction(void)
+{
+ if (replay_state.skipping_instruction) {
+ return true;
+ }
+
+ if (replay_mode == REPLAY_MODE_PLAY) {
+ skip_async_events(EVENT_INSTRUCTION);
+ if (replay_data_kind != EVENT_INSTRUCTION
+ && replay_data_kind != EVENT_ASYNC) {
+ return false;
+ }
+ }
+ return true;
+}
+
+uint64_t replay_get_current_step(void)
+{
+ if (first_cpu == NULL) {
+ return 0;
+ }
+ if (replay_file) {
+ if (replay_mode == REPLAY_MODE_RECORD) {
+ return replay_state.current_step + first_cpu->instructions_count;
+ }
+ }
+ return replay_state.current_step;
+}
@@ -12,6 +12,8 @@
*
*/
+#include <stdbool.h>
+#include <stdint.h>
#include "qapi-types.h"
extern ReplayMode replay_mode;
@@ -20,4 +22,17 @@ extern char *replay_image_suffix;
/*! Returns replay play submode */
ReplaySubmode replay_get_play_submode(void);
+/* Processing the instructions */
+
+/*! Returns number of executed instructions. */
+uint64_t replay_get_current_step(void);
+/*! Called before instruction execution */
+void replay_instruction(int process_events);
+/*! Undo last instruction count, when exception occurs */
+void replay_undo_last_instruction(void);
+/*! Returns true if asynchronous event is pending */
+bool replay_has_async_request(void);
+/*! Returns non-zero if next event is instruction. */
+bool replay_has_instruction(void);
+
#endif
@@ -59,6 +59,7 @@
#include "exec/cputlb.h"
#include "translate-all.h"
#include "qemu/timer.h"
+#include "replay/replay.h"
//#define DEBUG_TB_INVALIDATE
//#define DEBUG_FLUSH
@@ -1171,6 +1172,9 @@ void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
cpu_restore_state_from_tb(cpu, current_tb, cpu->mem_io_pc);
cpu_get_tb_cpu_state(env, ¤t_pc, ¤t_cs_base,
¤t_flags);
+ /* Current instruction is already processed by replay.
+ Set flags that allow skpping this event */
+ replay_undo_last_instruction();
}
#endif /* TARGET_HAS_PRECISE_SMC */
/* we need to do that to handle the case where a signal
@@ -1290,6 +1294,9 @@ static void tb_invalidate_phys_page(tb_page_addr_t addr,
cpu_restore_state_from_tb(cpu, current_tb, pc);
cpu_get_tb_cpu_state(env, ¤t_pc, ¤t_cs_base,
¤t_flags);
+ /* Current instruction is already processed by replay.
+ Set flags that allow skpping this event */
+ replay_undo_last_instruction();
}
#endif /* TARGET_HAS_PRECISE_SMC */
tb_phys_invalidate(tb, addr);
This patch adds instructions count fields to cpu structure and invents several functions for increasing this counter while executing translation blocks. Signed-off-by: Pavel Dovgalyuk <pavel.dovgaluk@ispras.ru> --- cpu-exec.c | 14 ++++- cpus.c | 5 ++ exec.c | 4 + include/exec/cpu-defs.h | 2 + include/qom/cpu.h | 3 + replay/Makefile.objs | 1 replay/replay-events.c | 26 +++++++++ replay/replay-internal.c | 14 +++++ replay/replay-internal.h | 37 ++++++++++++- replay/replay.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++ replay/replay.h | 15 +++++ translate-all.c | 7 ++ 12 files changed, 258 insertions(+), 5 deletions(-) create mode 100755 replay/replay-events.c