[mirror_qemu.git] / replay / replay-events.c

/*
 * replay-events.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 "qemu/error-report.h"
#include "sysemu/replay.h"
#include "replay-internal.h"
#include "block/aio.h"
#include "ui/input.h"

typedef struct Event {
    ReplayAsyncEventKind event_kind;
    void *opaque;
    void *opaque2;
    uint64_t id;

    QTAILQ_ENTRY(Event) events;
} Event;

static QTAILQ_HEAD(, Event) events_list = QTAILQ_HEAD_INITIALIZER(events_list);
static bool events_enabled;

/* Functions */

static void replay_run_event(Event *event)
{
    switch (event->event_kind) {
    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);
        break;
    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);
        exit(1);
        break;
    }
}

void replay_enable_events(void)
{
    if (replay_mode != REPLAY_MODE_NONE) {
        events_enabled = true;
    }
}

bool replay_has_events(void)
{
    return !QTAILQ_EMPTY(&events_list);
}

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

    g_assert(replay_mutex_locked());

    while (!QTAILQ_EMPTY(&events_list)) {
        Event *event = QTAILQ_FIRST(&events_list);
        replay_run_event(event);
        QTAILQ_REMOVE(&events_list, event, events);
        g_free(event);
    }
}

void replay_disable_events(void)
{
    if (replay_mode != REPLAY_MODE_NONE) {
        events_enabled = false;
        /* Flush events queue before waiting of completion */
        replay_flush_events();
    }
}

/*! Adds specified async event to the queue */
void replay_add_event(ReplayAsyncEventKind event_kind,
                      void *opaque,
                      void *opaque2, uint64_t id)
{
    assert(event_kind < REPLAY_ASYNC_COUNT);

    if (!replay_file || replay_mode == REPLAY_MODE_NONE
        || !events_enabled) {
        Event e;
        e.event_kind = event_kind;
        e.opaque = opaque;
        e.opaque2 = opaque2;
        e.id = id;
        replay_run_event(&e);
        return;
    }

    Event *event = g_malloc0(sizeof(Event));
    event->event_kind = event_kind;
    event->opaque = opaque;
    event->opaque2 = opaque2;
    event->id = id;

    g_assert(replay_mutex_locked());
    QTAILQ_INSERT_TAIL(&events_list, event, events);
}

void replay_bh_schedule_event(QEMUBH *bh)
{
    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);
}

void replay_add_input_sync_event(void)
{
    replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0);
}

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, int checkpoint)
{
    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);

        /* 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:
            replay_save_input_event(event->opaque);
            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 %" PRId64 " of replay event", event->id);
            exit(1);
        }
    }
}

/* Called with replay mutex locked */
void replay_save_events(int checkpoint)
{
    g_assert(replay_mutex_locked());
    g_assert(checkpoint != CHECKPOINT_CLOCK_WARP_START);
    g_assert(checkpoint != CHECKPOINT_CLOCK_VIRTUAL);
    while (!QTAILQ_EMPTY(&events_list)) {
        Event *event = QTAILQ_FIRST(&events_list);
        replay_save_event(event, checkpoint);
        replay_run_event(event);
        QTAILQ_REMOVE(&events_list, event, events);
        g_free(event);
    }
}

static Event *replay_read_event(int checkpoint)
{
    Event *event;
    if (replay_state.read_event_kind == -1) {
        replay_state.read_event_checkpoint = replay_get_byte();
        replay_state.read_event_kind = replay_get_byte();
        replay_state.read_event_id = -1;
        replay_check_error();
    }

    if (checkpoint != replay_state.read_event_checkpoint) {
        return NULL;
    }

    /* Events that has not to be in the queue */
    switch (replay_state.read_event_kind) {
    case REPLAY_ASYNC_EVENT_BH:
    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 = replay_state.read_event_kind;
        event->opaque = replay_read_input_event();
        return event;
    case REPLAY_ASYNC_EVENT_INPUT_SYNC:
        event = g_malloc0(sizeof(Event));
        event->event_kind = replay_state.read_event_kind;
        event->opaque = 0;
        return event;
    case REPLAY_ASYNC_EVENT_CHAR_READ:
        event = g_malloc0(sizeof(Event));
        event->event_kind = replay_state.read_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_malloc0(sizeof(Event));
        event->event_kind = replay_state.read_event_kind;
        event->opaque = replay_event_net_load();
        return event;
    default:
        error_report("Unknown ID %d of replay event",
            replay_state.read_event_kind);
        exit(1);
        break;
    }

    QTAILQ_FOREACH(event, &events_list, events) {
        if (event->event_kind == replay_state.read_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)
{
    g_assert(replay_mutex_locked());
    while (replay_state.data_kind == EVENT_ASYNC) {
        Event *event = replay_read_event(checkpoint);
        if (!event) {
            break;
        }
        replay_finish_event();
        replay_state.read_event_kind = -1;
        replay_run_event(event);

        g_free(event);
    }
}

void replay_init_events(void)
{
    replay_state.read_event_kind = -1;
}

void replay_finish_events(void)
{
    events_enabled = false;
    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;
}
Commit	Line	Data
c0c071d0 PD	1	/*
	2	* replay-events.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"
c0c071d0 PD	13	#include "qemu/error-report.h"
	14	#include "sysemu/replay.h"
	15	#include "replay-internal.h"
8a354bd9	16	#include "block/aio.h"
ee312992	17	#include "ui/input.h"
c0c071d0 PD	18
	19	typedef struct Event {
	20	ReplayAsyncEventKind event_kind;
	21	void *opaque;
	22	void *opaque2;
	23	uint64_t id;
	24
	25	QTAILQ_ENTRY(Event) events;
	26	} Event;
	27
	28	static QTAILQ_HEAD(, Event) events_list = QTAILQ_HEAD_INITIALIZER(events_list);
c0c071d0 PD	29	static bool events_enabled;
	30
	31	/* Functions */
	32
	33	static void replay_run_event(Event *event)
	34	{
	35	switch (event->event_kind) {
8a354bd9 PD	36	case REPLAY_ASYNC_EVENT_BH:
	37	aio_bh_call(event->opaque);
	38	break;
e4ec5ad4 PD	39	case REPLAY_ASYNC_EVENT_BH_ONESHOT:
	40	((QEMUBHFunc *)event->opaque)(event->opaque2);
	41	break;
ee312992 PD	42	case REPLAY_ASYNC_EVENT_INPUT:
	43	qemu_input_event_send_impl(NULL, (InputEvent *)event->opaque);
	44	qapi_free_InputEvent((InputEvent *)event->opaque);
	45	break;
	46	case REPLAY_ASYNC_EVENT_INPUT_SYNC:
	47	qemu_input_event_sync_impl();
	48	break;
33577b47 PD	49	case REPLAY_ASYNC_EVENT_CHAR_READ:
	50	replay_event_char_read_run(event->opaque);
	51	break;
63785678 PD	52	case REPLAY_ASYNC_EVENT_BLOCK:
	53	aio_bh_call(event->opaque);
	54	break;
646c5478 PD	55	case REPLAY_ASYNC_EVENT_NET:
	56	replay_event_net_run(event->opaque);
	57	break;
c0c071d0 PD	58	default:
	59	error_report("Replay: invalid async event ID (%d) in the queue",
	60	event->event_kind);
	61	exit(1);
	62	break;
	63	}
	64	}
	65
	66	void replay_enable_events(void)
	67	{
1652e0c3 PD	68	if (replay_mode != REPLAY_MODE_NONE) {
	69	events_enabled = true;
	70	}
c0c071d0 PD	71	}
	72
	73	bool replay_has_events(void)
	74	{
	75	return !QTAILQ_EMPTY(&events_list);
	76	}
	77
	78	void replay_flush_events(void)
	79	{
f9a9fb65 PD	80	if (replay_mode == REPLAY_MODE_NONE) {
	81	return;
	82	}
	83
d759c951 AB	84	g_assert(replay_mutex_locked());
d759c951 AB	85
c0c071d0 PD	86	while (!QTAILQ_EMPTY(&events_list)) {
c0c071d0 PD	87	Event *event = QTAILQ_FIRST(&events_list);
c0c071d0	88	replay_run_event(event);
c0c071d0 PD	89	QTAILQ_REMOVE(&events_list, event, events);
	90	g_free(event);
	91	}
c0c071d0 PD	92	}
	93
	94	void replay_disable_events(void)
	95	{
	96	if (replay_mode != REPLAY_MODE_NONE) {
	97	events_enabled = false;
	98	/* Flush events queue before waiting of completion */
	99	replay_flush_events();
	100	}
	101	}
	102
c0c071d0	103	/! Adds specified async event to the queue /
33577b47 PD	104	void replay_add_event(ReplayAsyncEventKind event_kind,
	105	void *opaque,
	106	void *opaque2, uint64_t id)
c0c071d0 PD	107	{
	108	assert(event_kind < REPLAY_ASYNC_COUNT);
	109
	110	if (!replay_file \|\| replay_mode == REPLAY_MODE_NONE
	111	\|\| !events_enabled) {
	112	Event e;
	113	e.event_kind = event_kind;
	114	e.opaque = opaque;
	115	e.opaque2 = opaque2;
	116	e.id = id;
	117	replay_run_event(&e);
	118	return;
	119	}
	120
	121	Event *event = g_malloc0(sizeof(Event));
	122	event->event_kind = event_kind;
	123	event->opaque = opaque;
	124	event->opaque2 = opaque2;
	125	event->id = id;
	126
d759c951	127	g_assert(replay_mutex_locked());
c0c071d0	128	QTAILQ_INSERT_TAIL(&events_list, event, events);
c0c071d0	129	}
8a354bd9 PD	130
	131	void replay_bh_schedule_event(QEMUBH *bh)
	132	{
1652e0c3	133	if (events_enabled) {
13f26713	134	uint64_t id = replay_get_current_icount();
8a354bd9 PD	135	replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
	136	} else {
	137	qemu_bh_schedule(bh);
	138	}
	139	}
c0c071d0	140
e4ec5ad4 PD	141	void replay_bh_schedule_oneshot_event(AioContext *ctx,
	142	QEMUBHFunc cb, void opaque)
	143	{
	144	if (events_enabled) {
	145	uint64_t id = replay_get_current_icount();
	146	replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id);
	147	} else {
	148	aio_bh_schedule_oneshot(ctx, cb, opaque);
	149	}
	150	}
	151
ee312992 PD	152	void replay_add_input_event(struct InputEvent *event)
	153	{
	154	replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0);
	155	}
	156
	157	void replay_add_input_sync_event(void)
	158	{
	159	replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0);
	160	}
	161
63785678 PD	162	void replay_block_event(QEMUBH *bh, uint64_t id)
63785678 PD	163	{
1652e0c3	164	if (events_enabled) {
63785678 PD	165	replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
	166	} else {
	167	qemu_bh_schedule(bh);
	168	}
	169	}
	170
c0c071d0 PD	171	static void replay_save_event(Event *event, int checkpoint)
	172	{
	173	if (replay_mode != REPLAY_MODE_PLAY) {
	174	/* put the event into the file */
	175	replay_put_event(EVENT_ASYNC);
	176	replay_put_byte(checkpoint);
	177	replay_put_byte(event->event_kind);
	178
	179	/* save event-specific data */
	180	switch (event->event_kind) {
8a354bd9	181	case REPLAY_ASYNC_EVENT_BH:
e4ec5ad4	182	case REPLAY_ASYNC_EVENT_BH_ONESHOT:
8a354bd9 PD	183	replay_put_qword(event->id);
8a354bd9 PD	184	break;
ee312992 PD	185	case REPLAY_ASYNC_EVENT_INPUT:
	186	replay_save_input_event(event->opaque);
	187	break;
	188	case REPLAY_ASYNC_EVENT_INPUT_SYNC:
	189	break;
33577b47 PD	190	case REPLAY_ASYNC_EVENT_CHAR_READ:
	191	replay_event_char_read_save(event->opaque);
	192	break;
63785678 PD	193	case REPLAY_ASYNC_EVENT_BLOCK:
	194	replay_put_qword(event->id);
	195	break;
646c5478 PD	196	case REPLAY_ASYNC_EVENT_NET:
	197	replay_event_net_save(event->opaque);
	198	break;
c0c071d0	199	default:
95b4aed5	200	error_report("Unknown ID %" PRId64 " of replay event", event->id);
c0c071d0	201	exit(1);
c0c071d0 PD	202	}
	203	}
	204	}
	205
	206	/* Called with replay mutex locked */
	207	void replay_save_events(int checkpoint)
	208	{
d759c951	209	g_assert(replay_mutex_locked());
89e46eb4	210	g_assert(checkpoint != CHECKPOINT_CLOCK_WARP_START);
ca9759c2	211	g_assert(checkpoint != CHECKPOINT_CLOCK_VIRTUAL);
c0c071d0 PD	212	while (!QTAILQ_EMPTY(&events_list)) {
	213	Event *event = QTAILQ_FIRST(&events_list);
	214	replay_save_event(event, checkpoint);
c0c071d0	215	replay_run_event(event);
c0c071d0 PD	216	QTAILQ_REMOVE(&events_list, event, events);
	217	g_free(event);
	218	}
	219	}
	220
	221	static Event *replay_read_event(int checkpoint)
	222	{
	223	Event *event;
0b30dc01 PD	224	if (replay_state.read_event_kind == -1) {
	225	replay_state.read_event_checkpoint = replay_get_byte();
	226	replay_state.read_event_kind = replay_get_byte();
	227	replay_state.read_event_id = -1;
c0c071d0 PD	228	replay_check_error();
	229	}
	230
0b30dc01	231	if (checkpoint != replay_state.read_event_checkpoint) {
c0c071d0 PD	232	return NULL;
	233	}
	234
	235	/* Events that has not to be in the queue */
0b30dc01	236	switch (replay_state.read_event_kind) {
8a354bd9	237	case REPLAY_ASYNC_EVENT_BH:
e4ec5ad4	238	case REPLAY_ASYNC_EVENT_BH_ONESHOT:
0b30dc01 PD	239	if (replay_state.read_event_id == -1) {
0b30dc01 PD	240	replay_state.read_event_id = replay_get_qword();
8a354bd9 PD	241	}
8a354bd9 PD	242	break;
ee312992 PD	243	case REPLAY_ASYNC_EVENT_INPUT:
ee312992 PD	244	event = g_malloc0(sizeof(Event));
0b30dc01	245	event->event_kind = replay_state.read_event_kind;
ee312992 PD	246	event->opaque = replay_read_input_event();
	247	return event;
	248	case REPLAY_ASYNC_EVENT_INPUT_SYNC:
	249	event = g_malloc0(sizeof(Event));
0b30dc01	250	event->event_kind = replay_state.read_event_kind;
ee312992 PD	251	event->opaque = 0;
ee312992 PD	252	return event;
33577b47 PD	253	case REPLAY_ASYNC_EVENT_CHAR_READ:
33577b47 PD	254	event = g_malloc0(sizeof(Event));
0b30dc01	255	event->event_kind = replay_state.read_event_kind;
33577b47 PD	256	event->opaque = replay_event_char_read_load();
33577b47 PD	257	return event;
63785678	258	case REPLAY_ASYNC_EVENT_BLOCK:
0b30dc01 PD	259	if (replay_state.read_event_id == -1) {
0b30dc01 PD	260	replay_state.read_event_id = replay_get_qword();
63785678 PD	261	}
63785678 PD	262	break;
646c5478 PD	263	case REPLAY_ASYNC_EVENT_NET:
646c5478 PD	264	event = g_malloc0(sizeof(Event));
0b30dc01	265	event->event_kind = replay_state.read_event_kind;
646c5478 PD	266	event->opaque = replay_event_net_load();
646c5478 PD	267	return event;
c0c071d0	268	default:
0b30dc01 PD	269	error_report("Unknown ID %d of replay event",
0b30dc01 PD	270	replay_state.read_event_kind);
c0c071d0 PD	271	exit(1);
	272	break;
	273	}
	274
	275	QTAILQ_FOREACH(event, &events_list, events) {
0b30dc01 PD	276	if (event->event_kind == replay_state.read_event_kind
	277	&& (replay_state.read_event_id == -1
	278	\|\| replay_state.read_event_id == event->id)) {
c0c071d0 PD	279	break;
	280	}
	281	}
	282
	283	if (event) {
	284	QTAILQ_REMOVE(&events_list, event, events);
	285	} else {
	286	return NULL;
	287	}
	288
	289	/* Read event-specific data */
	290
	291	return event;
	292	}
	293
	294	/* Called with replay mutex locked */
	295	void replay_read_events(int checkpoint)
	296	{
d759c951	297	g_assert(replay_mutex_locked());
f186d64d	298	while (replay_state.data_kind == EVENT_ASYNC) {
c0c071d0 PD	299	Event *event = replay_read_event(checkpoint);
	300	if (!event) {
	301	break;
	302	}
1a96e3c1	303	replay_finish_event();
0b30dc01	304	replay_state.read_event_kind = -1;
c0c071d0	305	replay_run_event(event);
c0c071d0 PD	306
c0c071d0 PD	307	g_free(event);
c0c071d0 PD	308	}
	309	}
	310
	311	void replay_init_events(void)
	312	{
0b30dc01	313	replay_state.read_event_kind = -1;
c0c071d0 PD	314	}
	315
	316	void replay_finish_events(void)
	317	{
	318	events_enabled = false;
d873fe03	319	replay_flush_events();
c0c071d0 PD	320	}
	321
	322	bool replay_events_enabled(void)
	323	{
	324	return events_enabled;
	325	}
6d0ceb80 PD	326
	327	uint64_t blkreplay_next_id(void)
	328	{
	329	if (replay_events_enabled()) {
	330	return replay_state.block_request_id++;
	331	}
	332	return 0;
	333	}