qemu

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

12
#include "qemu/osdep.h"
13
#include "qemu/error-report.h"
14
#include "sysemu/replay.h"
15
#include "replay-internal.h"
16
#include "block/aio.h"
17
#include "ui/input.h"
18
#include "hw/core/cpu.h"
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);
30
static bool events_enabled;
31

32
/* Functions */
33

34
static void replay_run_event(Event *event)
35
{
36
    switch (event->event_kind) {
37
    case REPLAY_ASYNC_EVENT_BH:
38
        aio_bh_call(event->opaque);
39
        break;
40
    case REPLAY_ASYNC_EVENT_BH_ONESHOT:
41
        ((QEMUBHFunc *)event->opaque)(event->opaque2);
42
        break;
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;
50
    case REPLAY_ASYNC_EVENT_CHAR_READ:
51
        replay_event_char_read_run(event->opaque);
52
        break;
53
    case REPLAY_ASYNC_EVENT_BLOCK:
54
        aio_bh_call(event->opaque);
55
        break;
56
    case REPLAY_ASYNC_EVENT_NET:
57
        replay_event_net_run(event->opaque);
58
        break;
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
{
69
    if (replay_mode != REPLAY_MODE_NONE) {
70
        events_enabled = true;
71
    }
72
}
73

74
bool replay_has_events(void)
75
{
76
    return !QTAILQ_EMPTY(&events_list);
77
}
78

79
void replay_flush_events(void)
80
{
81
    if (replay_mode == REPLAY_MODE_NONE) {
82
        return;
83
    }
84

85
    g_assert(replay_mutex_locked());
86

87
    while (!QTAILQ_EMPTY(&events_list)) {
88
        Event *event = QTAILQ_FIRST(&events_list);
89
        replay_run_event(event);
90
        QTAILQ_REMOVE(&events_list, event, events);
91
        g_free(event);
92
    }
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

104
/*! Adds specified async event to the queue */
105
void replay_add_event(ReplayAsyncEventKind event_kind,
106
                      void *opaque,
107
                      void *opaque2, uint64_t id)
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

122
    Event *event = g_new0(Event, 1);
123
    event->event_kind = event_kind;
124
    event->opaque = opaque;
125
    event->opaque2 = opaque2;
126
    event->id = id;
127

128
    g_assert(replay_mutex_locked());
129
    QTAILQ_INSERT_TAIL(&events_list, event, events);
130
    qemu_cpu_kick(first_cpu);
131
}
132

133
void replay_bh_schedule_event(QEMUBH *bh)
134
{
135
    if (events_enabled) {
136
        uint64_t id = replay_get_current_icount();
137
        replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
138
    } else {
139
        qemu_bh_schedule(bh);
140
    }
141
}
142

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

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

164
void replay_block_event(QEMUBH *bh, uint64_t id)
165
{
166
    if (events_enabled) {
167
        replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
168
    } else {
169
        qemu_bh_schedule(bh);
170
    }
171
}
172

173
static void replay_save_event(Event *event)
174
{
175
    if (replay_mode != REPLAY_MODE_PLAY) {
176
        /* put the event into the file */
177
        g_assert(event->event_kind < REPLAY_ASYNC_COUNT);
178
        replay_put_event(EVENT_ASYNC + event->event_kind);
179

180
        /* save event-specific data */
181
        switch (event->event_kind) {
182
        case REPLAY_ASYNC_EVENT_BH:
183
        case REPLAY_ASYNC_EVENT_BH_ONESHOT:
184
            replay_put_qword(event->id);
185
            break;
186
        case REPLAY_ASYNC_EVENT_INPUT:
187
            replay_save_input_event(event->opaque);
188
            break;
189
        case REPLAY_ASYNC_EVENT_INPUT_SYNC:
190
            break;
191
        case REPLAY_ASYNC_EVENT_CHAR_READ:
192
            replay_event_char_read_save(event->opaque);
193
            break;
194
        case REPLAY_ASYNC_EVENT_BLOCK:
195
            replay_put_qword(event->id);
196
            break;
197
        case REPLAY_ASYNC_EVENT_NET:
198
            replay_event_net_save(event->opaque);
199
            break;
200
        default:
201
            error_report("Unknown ID %" PRId64 " of replay event", event->id);
202
            exit(1);
203
        }
204
    }
205
}
206

207
/* Called with replay mutex locked */
208
void replay_save_events(void)
209
{
210
    g_assert(replay_mutex_locked());
211
    while (!QTAILQ_EMPTY(&events_list)) {
212
        Event *event = QTAILQ_FIRST(&events_list);
213
        replay_save_event(event);
214
        replay_run_event(event);
215
        QTAILQ_REMOVE(&events_list, event, events);
216
        g_free(event);
217
    }
218
}
219

220
static Event *replay_read_event(void)
221
{
222
    Event *event;
223
    ReplayAsyncEventKind event_kind = replay_state.data_kind - EVENT_ASYNC;
224

225
    /* Events that has not to be in the queue */
226
    switch (event_kind) {
227
    case REPLAY_ASYNC_EVENT_BH:
228
    case REPLAY_ASYNC_EVENT_BH_ONESHOT:
229
        if (replay_state.read_event_id == -1) {
230
            replay_state.read_event_id = replay_get_qword();
231
        }
232
        break;
233
    case REPLAY_ASYNC_EVENT_INPUT:
234
        event = g_new0(Event, 1);
235
        event->event_kind = event_kind;
236
        event->opaque = replay_read_input_event();
237
        return event;
238
    case REPLAY_ASYNC_EVENT_INPUT_SYNC:
239
        event = g_new0(Event, 1);
240
        event->event_kind = event_kind;
241
        event->opaque = 0;
242
        return event;
243
    case REPLAY_ASYNC_EVENT_CHAR_READ:
244
        event = g_new0(Event, 1);
245
        event->event_kind = event_kind;
246
        event->opaque = replay_event_char_read_load();
247
        return event;
248
    case REPLAY_ASYNC_EVENT_BLOCK:
249
        if (replay_state.read_event_id == -1) {
250
            replay_state.read_event_id = replay_get_qword();
251
        }
252
        break;
253
    case REPLAY_ASYNC_EVENT_NET:
254
        event = g_new0(Event, 1);
255
        event->event_kind = event_kind;
256
        event->opaque = replay_event_net_load();
257
        return event;
258
    default:
259
        error_report("Unknown ID %d of replay event", event_kind);
260
        exit(1);
261
        break;
262
    }
263

264
    QTAILQ_FOREACH(event, &events_list, events) {
265
        if (event->event_kind == event_kind
266
            && (replay_state.read_event_id == -1
267
                || replay_state.read_event_id == event->id)) {
268
            break;
269
        }
270
    }
271

272
    if (event) {
273
        QTAILQ_REMOVE(&events_list, event, events);
274
    }
275

276
    return event;
277
}
278

279
/* Called with replay mutex locked */
280
void replay_read_events(void)
281
{
282
    g_assert(replay_mutex_locked());
283
    while (replay_state.data_kind >= EVENT_ASYNC
284
        && replay_state.data_kind <= EVENT_ASYNC_LAST) {
285
        Event *event = replay_read_event();
286
        if (!event) {
287
            break;
288
        }
289
        replay_finish_event();
290
        replay_state.read_event_id = -1;
291
        replay_run_event(event);
292

293
        g_free(event);
294
    }
295
}
296

297
void replay_init_events(void)
298
{
299
    replay_state.read_event_id = -1;
300
}
301

302
void replay_finish_events(void)
303
{
304
    events_enabled = false;
305
    replay_flush_events();
306
}
307

308
bool replay_events_enabled(void)
309
{
310
    return events_enabled;
311
}
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
}
320