*
*/
-#include "qemu-common.h"
+#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "sysemu/replay.h"
#include "replay-internal.h"
#include "block/aio.h"
#include "ui/input.h"
+#include "hw/core/cpu.h"
typedef struct Event {
ReplayAsyncEventKind event_kind;
} Event;
static QTAILQ_HEAD(, Event) events_list = QTAILQ_HEAD_INITIALIZER(events_list);
-static unsigned int read_event_kind = -1;
-static uint64_t read_id = -1;
-static int read_checkpoint = -1;
-
static bool events_enabled;
/* Functions */
case REPLAY_ASYNC_EVENT_BH:
aio_bh_call(event->opaque);
break;
+ case REPLAY_ASYNC_EVENT_BH_ONESHOT:
+ ((QEMUBHFunc *)event->opaque)(event->opaque2);
+ break;
case REPLAY_ASYNC_EVENT_INPUT:
qemu_input_event_send_impl(NULL, (InputEvent *)event->opaque);
qapi_free_InputEvent((InputEvent *)event->opaque);
case REPLAY_ASYNC_EVENT_INPUT_SYNC:
qemu_input_event_sync_impl();
break;
+ case REPLAY_ASYNC_EVENT_CHAR_READ:
+ replay_event_char_read_run(event->opaque);
+ break;
+ case REPLAY_ASYNC_EVENT_BLOCK:
+ aio_bh_call(event->opaque);
+ break;
+ case REPLAY_ASYNC_EVENT_NET:
+ replay_event_net_run(event->opaque);
+ break;
default:
error_report("Replay: invalid async event ID (%d) in the queue",
event->event_kind);
void replay_enable_events(void)
{
- events_enabled = true;
+ if (replay_mode != REPLAY_MODE_NONE) {
+ events_enabled = true;
+ }
}
bool replay_has_events(void)
void replay_flush_events(void)
{
- replay_mutex_lock();
+ if (replay_mode == REPLAY_MODE_NONE) {
+ return;
+ }
+
+ g_assert(replay_mutex_locked());
+
while (!QTAILQ_EMPTY(&events_list)) {
Event *event = QTAILQ_FIRST(&events_list);
- replay_mutex_unlock();
replay_run_event(event);
- replay_mutex_lock();
QTAILQ_REMOVE(&events_list, event, events);
g_free(event);
}
- replay_mutex_unlock();
}
void replay_disable_events(void)
}
}
-void replay_clear_events(void)
-{
- replay_mutex_lock();
- while (!QTAILQ_EMPTY(&events_list)) {
- Event *event = QTAILQ_FIRST(&events_list);
- QTAILQ_REMOVE(&events_list, event, events);
-
- g_free(event);
- }
- replay_mutex_unlock();
-}
-
/*! Adds specified async event to the queue */
-static void replay_add_event(ReplayAsyncEventKind event_kind,
- void *opaque,
- void *opaque2, uint64_t id)
+void replay_add_event(ReplayAsyncEventKind event_kind,
+ void *opaque,
+ void *opaque2, uint64_t id)
{
assert(event_kind < REPLAY_ASYNC_COUNT);
return;
}
- Event *event = g_malloc0(sizeof(Event));
+ Event *event = g_new0(Event, 1);
event->event_kind = event_kind;
event->opaque = opaque;
event->opaque2 = opaque2;
event->id = id;
- replay_mutex_lock();
+ g_assert(replay_mutex_locked());
QTAILQ_INSERT_TAIL(&events_list, event, events);
- replay_mutex_unlock();
+ qemu_cpu_kick(first_cpu);
}
void replay_bh_schedule_event(QEMUBH *bh)
{
- if (replay_mode != REPLAY_MODE_NONE) {
- uint64_t id = replay_get_current_step();
+ if (events_enabled) {
+ uint64_t id = replay_get_current_icount();
replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
} else {
qemu_bh_schedule(bh);
}
}
+void replay_bh_schedule_oneshot_event(AioContext *ctx,
+ QEMUBHFunc *cb, void *opaque)
+{
+ if (events_enabled) {
+ uint64_t id = replay_get_current_icount();
+ replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id);
+ } else {
+ aio_bh_schedule_oneshot(ctx, cb, opaque);
+ }
+}
+
void replay_add_input_event(struct InputEvent *event)
{
replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0);
replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0);
}
-static void replay_save_event(Event *event, int checkpoint)
+void replay_block_event(QEMUBH *bh, uint64_t id)
+{
+ if (events_enabled) {
+ replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
+ } else {
+ qemu_bh_schedule(bh);
+ }
+}
+
+static void replay_save_event(Event *event)
{
if (replay_mode != REPLAY_MODE_PLAY) {
/* put the event into the file */
- replay_put_event(EVENT_ASYNC);
- replay_put_byte(checkpoint);
- replay_put_byte(event->event_kind);
+ g_assert(event->event_kind < REPLAY_ASYNC_COUNT);
+ replay_put_event(EVENT_ASYNC + event->event_kind);
/* save event-specific data */
switch (event->event_kind) {
case REPLAY_ASYNC_EVENT_BH:
+ case REPLAY_ASYNC_EVENT_BH_ONESHOT:
replay_put_qword(event->id);
break;
case REPLAY_ASYNC_EVENT_INPUT:
break;
case REPLAY_ASYNC_EVENT_INPUT_SYNC:
break;
+ case REPLAY_ASYNC_EVENT_CHAR_READ:
+ replay_event_char_read_save(event->opaque);
+ break;
+ case REPLAY_ASYNC_EVENT_BLOCK:
+ replay_put_qword(event->id);
+ break;
+ case REPLAY_ASYNC_EVENT_NET:
+ replay_event_net_save(event->opaque);
+ break;
default:
- error_report("Unknown ID %d of replay event", read_event_kind);
+ error_report("Unknown ID %" PRId64 " of replay event", event->id);
exit(1);
}
}
}
/* Called with replay mutex locked */
-void replay_save_events(int checkpoint)
+void replay_save_events(void)
{
+ g_assert(replay_mutex_locked());
while (!QTAILQ_EMPTY(&events_list)) {
Event *event = QTAILQ_FIRST(&events_list);
- replay_save_event(event, checkpoint);
-
- replay_mutex_unlock();
+ replay_save_event(event);
replay_run_event(event);
- replay_mutex_lock();
QTAILQ_REMOVE(&events_list, event, events);
g_free(event);
}
}
-static Event *replay_read_event(int checkpoint)
+static Event *replay_read_event(void)
{
Event *event;
- if (read_event_kind == -1) {
- read_checkpoint = replay_get_byte();
- read_event_kind = replay_get_byte();
- read_id = -1;
- replay_check_error();
- }
-
- if (checkpoint != read_checkpoint) {
- return NULL;
- }
+ ReplayAsyncEventKind event_kind = replay_state.data_kind - EVENT_ASYNC;
/* Events that has not to be in the queue */
- switch (read_event_kind) {
+ switch (event_kind) {
case REPLAY_ASYNC_EVENT_BH:
- if (read_id == -1) {
- read_id = replay_get_qword();
+ case REPLAY_ASYNC_EVENT_BH_ONESHOT:
+ if (replay_state.read_event_id == -1) {
+ replay_state.read_event_id = replay_get_qword();
}
break;
case REPLAY_ASYNC_EVENT_INPUT:
- event = g_malloc0(sizeof(Event));
- event->event_kind = read_event_kind;
+ event = g_new0(Event, 1);
+ event->event_kind = event_kind;
event->opaque = replay_read_input_event();
return event;
case REPLAY_ASYNC_EVENT_INPUT_SYNC:
- event = g_malloc0(sizeof(Event));
- event->event_kind = read_event_kind;
+ event = g_new0(Event, 1);
+ event->event_kind = event_kind;
event->opaque = 0;
return event;
+ case REPLAY_ASYNC_EVENT_CHAR_READ:
+ event = g_new0(Event, 1);
+ event->event_kind = event_kind;
+ event->opaque = replay_event_char_read_load();
+ return event;
+ case REPLAY_ASYNC_EVENT_BLOCK:
+ if (replay_state.read_event_id == -1) {
+ replay_state.read_event_id = replay_get_qword();
+ }
+ break;
+ case REPLAY_ASYNC_EVENT_NET:
+ event = g_new0(Event, 1);
+ event->event_kind = event_kind;
+ event->opaque = replay_event_net_load();
+ return event;
default:
- error_report("Unknown ID %d of replay event", read_event_kind);
+ error_report("Unknown ID %d of replay event", event_kind);
exit(1);
break;
}
QTAILQ_FOREACH(event, &events_list, events) {
- if (event->event_kind == read_event_kind
- && (read_id == -1 || read_id == event->id)) {
+ if (event->event_kind == event_kind
+ && (replay_state.read_event_id == -1
+ || replay_state.read_event_id == event->id)) {
break;
}
}
if (event) {
QTAILQ_REMOVE(&events_list, event, events);
- } else {
- return NULL;
}
- /* Read event-specific data */
-
return event;
}
/* Called with replay mutex locked */
-void replay_read_events(int checkpoint)
+void replay_read_events(void)
{
- while (replay_data_kind == EVENT_ASYNC) {
- Event *event = replay_read_event(checkpoint);
+ g_assert(replay_mutex_locked());
+ while (replay_state.data_kind >= EVENT_ASYNC
+ && replay_state.data_kind <= EVENT_ASYNC_LAST) {
+ Event *event = replay_read_event();
if (!event) {
break;
}
- replay_mutex_unlock();
+ replay_finish_event();
+ replay_state.read_event_id = -1;
replay_run_event(event);
- replay_mutex_lock();
g_free(event);
- replay_finish_event();
- read_event_kind = -1;
}
}
void replay_init_events(void)
{
- read_event_kind = -1;
+ replay_state.read_event_id = -1;
}
void replay_finish_events(void)
{
events_enabled = false;
- replay_clear_events();
+ replay_flush_events();
}
bool replay_events_enabled(void)
{
return events_enabled;
}
+
+uint64_t blkreplay_next_id(void)
+{
+ if (replay_events_enabled()) {
+ return replay_state.block_request_id++;
+ }
+ return 0;
+}
projects / mirror_qemu.git / blobdiff