[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"
#include "hw/core/cpu.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_new0(Event, 1);
    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);
    qemu_cpu_kick(first_cpu);
}

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)
{
    if (replay_mode != REPLAY_MODE_PLAY) {
        /* put the event into the file */
        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:
            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(void)
{
    g_assert(replay_mutex_locked());
    while (!QTAILQ_EMPTY(&events_list)) {
        Event *event = QTAILQ_FIRST(&events_list);
        replay_save_event(event);
        replay_run_event(event);
        QTAILQ_REMOVE(&events_list, event, events);
        g_free(event);
    }
}

static Event *replay_read_event(void)
{
    Event *event;
    ReplayAsyncEventKind event_kind = replay_state.data_kind - EVENT_ASYNC;

    /* Events that has not to be in the queue */
    switch (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_new0(Event, 1);
        event->event_kind = event_kind;
        event->opaque = replay_read_input_event();
        return event;
    case REPLAY_ASYNC_EVENT_INPUT_SYNC:
        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", event_kind);
        exit(1);
        break;
    }

    QTAILQ_FOREACH(event, &events_list, events) {
        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);
    }

    return event;
}

/* Called with replay mutex locked */
void replay_read_events(void)
{
    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_finish_event();
        replay_state.read_event_id = -1;
        replay_run_event(event);

        g_free(event);
    }
}

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